[
  {
    "path": ".github/workflows/build.yml",
    "content": "name: build\non: [push, pull_request]\n\njobs:\n  build:\n    runs-on: ubuntu-latest\n\n    steps:\n      - uses: actions/checkout@master\n     \n      - name: Install Hunspell\n        run: |\n           sudo apt-get update\n           sudo apt-get install hunspell\n           \n      - name: Run cd scripts; make -k\n        run: cd scripts; make -k\n\n      - name: Run cd ..\n        run: cd ..\n"
  },
  {
    "path": ".github/workflows/jekyll-gh-pages.yml",
    "content": "# Sample workflow for building and deploying a Jekyll site to GitHub Pages\nname: Deploy Jekyll with GitHub Pages dependencies preinstalled\n\non:\n  # Runs on pushes targeting the default branch\n  push:\n    branches: [\"master\"]\n\n  # Allows you to run this workflow manually from the Actions tab\n  workflow_dispatch:\n\n# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages\npermissions:\n  contents: read\n  pages: write\n  id-token: write\n\n# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.\n# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.\nconcurrency:\n  group: \"pages\"\n  cancel-in-progress: false\n\njobs:\n  # Build job\n  build:\n    runs-on: ubuntu-latest\n    steps:\n      - name: Checkout\n        uses: actions/checkout@v6\n      - name: Setup Pages\n        uses: actions/configure-pages@v5\n      - name: Build with Jekyll\n        uses: actions/jekyll-build-pages@v1\n        with:\n          source: ./\n          destination: ./_site\n      - name: Upload artifact\n        uses: actions/upload-pages-artifact@v4\n\n  # Deployment job\n  deploy:\n    environment:\n      name: github-pages\n      url: ${{ steps.deployment.outputs.page_url }}\n    runs-on: ubuntu-latest\n    needs: build\n    steps:\n      - name: Deploy to GitHub Pages\n        id: deployment\n        uses: actions/deploy-pages@v4\n"
  },
  {
    "path": ".gitignore",
    "content": "scripts/build\nscripts/nodesjs/build\nnode_modules\n_site\nscripts/python/__pycache__\nscripts/python/*.pyc\n\n# VS Code\n.vs/\n\n# MacOS-specific\n.DS_Store"
  },
  {
    "path": ".travis.yml",
    "content": "# This is the configuration for Travis CI, a free github-integrated service that runs this script for each pull request (if configured)\n\n# provides gcc, clang, make, scons, cmake\nlanguage: c++\n\n# alternatives: gcc, clang, or both (as yaml list)\ncompiler: clang\n\naddons:\n  apt:\n    packages:\n    - hunspell\n\ninstall:\n -\n\nscript:\n - cd scripts; make -k\n - cd ..\n\nnotifications:\n  email: false\n"
  },
  {
    "path": "CONTRIBUTING.md",
    "content": "## Contributing to the C++ Core Guidelines\n\n>\"Within C++ is a smaller, simpler, safer language struggling to get out.\" \n>-- <cite>Bjarne Stroustrup</cite>\n\nThe C++ Core Guidelines are a collaborative effort led by Bjarne Stroustrup, much like the C++ language itself. They are the result of many \nperson-years of discussion and design across a number of organizations. Their design encourages general applicability and broad adoption but \nthey can be freely copied and modified to meet your organization's needs. \n\nWe encourage contributions to the C++ Core Guidelines in a number of ways:\n- **Individual feedback** Are you a developer who is passionate about your code? Join the discussion in \n[Issues](https://github.com/isocpp/CppCoreGuidelines/issues). We want to know which rules resonate with you and which don't. Were any rules\ninordinately difficult to apply? Does your compiler vendor's Guidelines Support Library (e.g., \n[Microsoft's implementation of the GSL](https://github.com/microsoft/gsl)) suit your needs in adopting these guidelines?\n- **Organizational adoption** While the guidelines are designed to be broadly adoptable they are also intended to be modified to fit your\norganization's particular needs. We encourage your organization to fork this repo and create your own copy of these guidelines with changes \nthat reflect your needs. We suggest that you make it clear in the title of your guidelines that these are your organization's fork of the\nguidelines and that you provide a link back to the original set of [guidelines](https://github.com/isocpp/CppCoreGuidelines). And if any of\nyour local changes are appropriate to pull back into the original guidelines, please open an \n[Issue](https://github.com/isocpp/CppCoreGuidelines/issues) which can lead to a pull request.\n- **Maintain the Guidelines** The C++ Core Guidelines were created from a wealth of knowledge spread across a number of organizations\nworldwide. If you or your organization is passionate about helping to create the guidelines, consider becoming an editor or maintainer. If\nyou're a C++ expert who is serious about participating, please \n[email coreguidelines@isocpp.org](mailto:coreguidelines@isocpp.org?subject=Maintain%20the%20C++%20Code%20Guidelines).\n \n## Contributor License Agreement\nBy contributing content to the C++ Core Guidelines (i.e., submitting a pull request for inclusion in this repository) you agree with the \n[Standard C++ Foundation](https://isocpp.org/about) [Terms of Use](https://isocpp.org/home/terms-of-use), especially all of the terms specified\nregarding Copyright and Patents.   \n- You warrant that your material is original, or you have the right to contribute it.\n- With respect to the material that you own, you grant a worldwide, non-exclusive, irrevocable, transferable, and royalty-free license to your contributed \nmaterial to Standard C++ Foundation to display, reproduce, perform, distribute, and create derivative works of that material for commercial or \nnon-commercial use. With respect to any other material you contribute, such material must be under a license sufficient to allow Standard C++ Foundation\nto display, reproduce, perform, distribute, and create derivative works of that material for commercial or non-commercial use.\n- You agree that, if your contributed material is subsequently reflected in the ISO/IEC C++ standard in any form, it will be subject to all ISO/IEC JTC \n1 policies including [copyrights](http://www.iso.org/iso/home/policies.htm), \n[patents](http://www.iso.org/iso/home/standards_development/governance_of_technical_work/patents.htm), and \n[procedures](http://www.itscj.ipsj.or.jp/sc29/29w7proc.htm); please direct any questions about these policies to the \n[ISO Central Secretariat](http://www.iso.org/iso/home/about.htm).\n\n\n## Pull requests\n\nWe welcome pull requests for scoped changes to the guidelines--bug fixes in\nexamples, clarifying ambiguous text, etc.  Significant changes should first be\ndiscussed in the [Issues](https://github.com/isocpp/CppCoreGuidelines/issues)\nand the Issue number must be included in the pull request.  For\nguideline-related changes, please specify the rule number in your Issue and/or\nPull Request.\n\nChanges should be made in a child commit of a recent commit in the master\nbranch.  If you are making many small changes, please create separate PRs to\nminimize merge issues.\n\n### Document Style Guidelines\n\nDocuments in this repository are written in an unspecific flavor of Markdown,\nwhich leaves some ambiguity for formatting text.  We ask that pull requests\nmaintain the following style guidelines, though we are aware that the document\nmay not already be consistent.\n\n#### Indentation\n\nCode and nested text should use multiples of 4 spaces of indentation, and no\ntab characters, like so:\n\n    void func(const int x)\n    {\n        std::cout << x << '\\n';\n    }\n\n#### Code Blocks\n\nPlease use 4-space indentation to trigger code parsing, rather than [fenced code blocks](https://help.github.com/articles/github-flavored-markdown/#fenced-code-blocks) or any other style, like so:\n\n    This is some document text, with an example below:\n\n        void func()\n        {\n            std::cout << \"This is code.\\n\";\n        }\n\n#### Document style decisions\n\nWe've discussed and made decisions on a number of document style. Please do not open PRs that revisit these stylistic points:\n\n- The CppCoreGuidelines.md file is a single GH-flavored Markdown file. It is not split into separate chapters.\n- We do not use syntax highlighting in the Core Guidelines. See PRs #33, #96, #328, and #779. If you want syntax highlighting you\ncan either view the \"pretty\" version at http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines or do your own post-processing.\n- We're sticking with the ASCII character set. We do not use Unicode em-dashes, Unicode spaces, or pretty quotes. Lots of people edit this file with their various text editors. ASCII is simple and universally understood. \n\n### Update dictionary\n\nCode samples in the guidelines are run through a spelling checker.  Be sure to add new class and variable names to [scripts/hunspell/isocpp.dic](https://github.com/isocpp/CppCoreGuidelines/blob/master/scripts/hunspell/isocpp.dic).\n\n### Miscellaneous\n\nTo avoid line-ending issues, please set `autocrlf = input` and `whitespace = cr-at-eol` in your git configuration.\n"
  },
  {
    "path": "CppCoreGuidelines.md",
    "content": "# <a name=\"main\"></a>C++ Core Guidelines\n\nJul 8, 2025\n\nEditors:\n\n* [Bjarne Stroustrup](https://www.stroustrup.com)\n* [Herb Sutter](https://herbsutter.com/)\n\nThis is a living document under continuous improvement.\nHad it been an open-source (code) project, this would have been release 0.8.\nCopying, use, modification, and creation of derivative works from this project is licensed under an MIT-style license.\nContributing to this project requires agreeing to a Contributor License. See the accompanying [LICENSE](https://github.com/isocpp/CppCoreGuidelines/blob/master/LICENSE) file for details.\nWe make this project available to \"friendly users\" to use, copy, modify, and derive from, hoping for constructive input.\n\nComments and suggestions for improvements are most welcome.\nWe plan to modify and extend this document as our understanding improves and the language and the set of available libraries improve.\nWhen commenting, please note [the introduction](#s-introduction) that outlines our aims and general approach.\nThe list of contributors is [here](#ss-ack).\n\nProblems:\n\n* The sets of rules have not been completely checked for completeness, consistency, or enforceability.\n* Triple question marks (???) mark known missing information.\n* Update reference sections; many pre-C++11 sources are too old.\n* For a more-or-less up-to-date to-do list see: [To-do: Unclassified proto-rules](#s-unclassified).\n\nYou can [read an explanation of the scope and structure of this Guide](#s-abstract) or just jump straight in:\n\n* [In: Introduction](#s-introduction)\n* [P: Philosophy](#s-philosophy)\n* [I: Interfaces](#s-interfaces)\n* [F: Functions](#s-functions)\n* [C: Classes and class hierarchies](#s-class)\n* [Enum: Enumerations](#s-enum)\n* [R: Resource management](#s-resource)\n* [ES: Expressions and statements](#s-expr)\n* [Per: Performance](#s-performance)\n* [CP: Concurrency and parallelism](#s-concurrency)\n* [E: Error handling](#s-errors)\n* [Con: Constants and immutability](#s-const)\n* [T: Templates and generic programming](#s-templates)\n* [CPL: C-style programming](#s-cpl)\n* [SF: Source files](#s-source)\n* [SL: The Standard Library](#sl-the-standard-library)\n\nSupporting sections:\n\n* [A: Architectural ideas](#s-a)\n* [NR: Non-Rules and myths](#s-not)\n* [RF: References](#s-references)\n* [Pro: Profiles](#s-profile)\n* [GSL: Guidelines support library](#s-gsl)\n* [NL: Naming and layout suggestions](#s-naming)\n* [FAQ: Answers to frequently asked questions](#s-faq)\n* [Appendix A: Libraries](#s-libraries)\n* [Appendix B: Modernizing code](#s-modernizing)\n* [Appendix C: Discussion](#s-discussion)\n* [Appendix D: Supporting tools](#s-tools)\n* [Glossary](#s-glossary)\n* [To-do: Unclassified proto-rules](#s-unclassified)\n\nYou can sample rules for specific language features:\n\n* assignment:\n[regular types](#rc-regular) --\n[prefer initialization](#rc-initialize) --\n[copy](#rc-copy-semantic) --\n[move](#rc-move-semantic) --\n[other operations](#rc-matched) --\n[default](#rc-eqdefault)\n* `class`:\n[data](#rc-org) --\n[invariant](#rc-struct) --\n[members](#rc-member) --\n[helpers](#rc-helper) --\n[concrete types](#ss-concrete) --\n[ctors, =, and dtors](#s-ctor) --\n[hierarchy](#ss-hier) --\n[operators](#ss-overload)\n* `concept`:\n[rules](#ss-concepts) --\n[in generic programming](#rt-raise) --\n[template arguments](#rt-concepts) --\n[semantics](#rt-low)\n* constructor:\n[invariant](#rc-struct) --\n[establish invariant](#rc-ctor) --\n[`throw`](#rc-throw) --\n[default](#rc-default0) --\n[not needed](#rc-default) --\n[`explicit`](#rc-explicit) --\n[delegating](#rc-delegating) --\n[`virtual`](#rc-ctor-virtual)\n* derived `class`:\n[when to use](#rh-domain) --\n[as interface](#rh-abstract) --\n[destructors](#rh-dtor) --\n[copy](#rh-copy) --\n[getters and setters](#rh-get) --\n[multiple inheritance](#rh-mi-interface) --\n[overloading](#rh-using) --\n[slicing](#rc-copy-virtual) --\n[`dynamic_cast`](#rh-dynamic_cast)\n* destructor:\n[and constructors](#rc-matched) --\n[when needed?](#rc-dtor) --\n[must not fail](#rc-dtor-fail)\n* exception:\n[errors](#s-errors) --\n[`throw`](#re-throw) --\n[for errors only](#re-errors) --\n[`noexcept`](#re-noexcept) --\n[minimize `try`](#re-catch) --\n[what if no exceptions?](#re-no-throw-codes)\n* `for`:\n[range-for and for](#res-for-range) --\n[for and while](#res-for-while) --\n[for-initializer](#res-for-init) --\n[empty body](#res-empty) --\n[loop variable](#res-loop-counter) --\n[loop variable type ???](#res-???)\n* function:\n[naming](#rf-package) --\n[single operation](#rf-logical) --\n[no throw](#rf-noexcept) --\n[arguments](#rf-smart) --\n[argument passing](#rf-conventional) --\n[multiple return values](#rf-out-multi) --\n[pointers](#rf-return-ptr) --\n[lambdas](#rf-capture-vs-overload)\n* `inline`:\n[small functions](#rf-inline) --\n[in headers](#rs-inline)\n* initialization:\n[always](#res-always) --\n[prefer `{}`](#res-list) --\n[lambdas](#res-lambda-init) --\n[default member initializers](#rc-in-class-initializer) --\n[class members](#rc-initialize) --\n[factory functions](#rc-factory)\n* lambda expression:\n[when to use](#ss-lambdas)\n* operator:\n[conventional](#ro-conventional) --\n[avoid conversion operators](#ro-conversion) --\n[and lambdas](#ro-lambda)\n* `public`, `private`, and `protected`:\n[information hiding](#rc-private) --\n[consistency](#rh-public) --\n[`protected`](#rh-protected)\n* `static_assert`:\n[compile-time checking](#rp-compile-time) --\n[and concepts](#rt-check-class)\n* `struct`:\n[for organizing data](#rc-org) --\n[use if no invariant](#rc-struct) --\n[no private members](#rc-class)\n* `template`:\n[abstraction](#rt-raise) --\n[containers](#rt-cont) --\n[concepts](#rt-concepts)\n* `unsigned`:\n[and signed](#res-mix) --\n[bit manipulation](#res-unsigned)\n* `virtual`:\n[interfaces](#ri-abstract) --\n[not `virtual`](#rc-concrete) --\n[destructor](#rc-dtor-virtual) --\n[never fail](#rc-dtor-fail)\n\nYou can look at design concepts used to express the rules:\n\n* assertion: ???\n* error: ???\n* exception: exception guarantee (???)\n* failure: ???\n* invariant: ???\n* leak: ???\n* library: ???\n* precondition: ???\n* postcondition: ???\n* resource: ???\n\n# <a name=\"s-abstract\"></a>Abstract\n\nThis document is a set of guidelines for using C++ well.\nThe aim of this document is to help people to use modern C++ effectively.\nBy \"modern C++\" we mean effective use of the ISO C++ standard (currently C++20, but almost all of our recommendations also apply to C++17, C++14 and C++11).\nIn other words, what would you like your code to look like in 5 years' time, given that you can start now? In 10 years' time?\n\nThe guidelines are focused on relatively high-level issues, such as interfaces, resource management, memory management, and concurrency.\nSuch rules affect application architecture and library design.\nFollowing the rules will lead to code that is statically type safe, has no resource leaks, and catches many more programming logic errors than is common in code today.\nAnd it will run fast -- you can afford to do things right.\n\nWe are less concerned with low-level issues, such as naming conventions and indentation style.\nHowever, no topic that can help a programmer is out of bounds.\n\nOur initial set of rules emphasizes safety (of various forms) and simplicity.\nThey might very well be too strict.\nWe expect to have to introduce more exceptions to better accommodate real-world needs.\nWe also need more rules.\n\nYou will find some of the rules contrary to your expectations or even contrary to your experience.\nIf we haven't suggested you change your coding style in any way, we have failed!\nPlease try to verify or disprove rules!\nIn particular, we'd really like to have some of our rules backed up with measurements or better examples.\n\nYou will find some of the rules obvious or even trivial.\nPlease remember that one purpose of a guideline is to help someone who is less experienced or coming from a different background or language to get up to speed.\n\nMany of the rules are designed to be supported by an analysis tool.\nViolations of rules will be flagged with references (or links) to the relevant rule.\nWe do not expect you to memorize all the rules before trying to write code.\nOne way of thinking about these guidelines is as a specification for tools that happens to be readable by humans.\n\nThe rules are meant for gradual introduction into a code base.\nWe plan to build tools for that and hope others will too.\n\nComments and suggestions for improvements are most welcome.\nWe plan to modify and extend this document as our understanding improves and the language and the set of available libraries improve.\n\n# <a name=\"s-introduction\"></a>In: Introduction\n\nThis is a set of core guidelines for modern C++ (currently C++20 and C++17) taking likely future enhancements and ISO Technical Specifications (TSs) into account.\nThe aim is to help C++ programmers to write simpler, more efficient, more maintainable code.\n\nIntroduction summary:\n\n* [In.target: Target readership](#ss-readers)\n* [In.aims: Aims](#ss-aims)\n* [In.not: Non-aims](#ss-non)\n* [In.force: Enforcement](#ss-force)\n* [In.struct: The structure of this document](#ss-struct)\n* [In.sec: Major sections](#ss-sec)\n\n## <a name=\"ss-readers\"></a>In.target: Target readership\n\nAll C++ programmers. This includes [programmers who might consider C](#s-cpl).\n\n## <a name=\"ss-aims\"></a>In.aims: Aims\n\nThe purpose of this document is to help developers to adopt modern C++ (currently C++20 and C++17) and to achieve a more uniform style across code bases.\n\nWe do not suffer the delusion that every one of these rules can be effectively applied to every code base. Upgrading old systems is hard. However, we do believe that a program that uses a rule is less error-prone and more maintainable than one that does not. Often, rules also lead to faster/easier initial development.\nAs far as we can tell, these rules lead to code that performs as well or better than older, more conventional techniques; they are meant to follow the zero-overhead principle (\"what you don't use, you don't pay for\" or \"when you use an abstraction mechanism appropriately, you get at least as good performance as if you had handcoded using lower-level language constructs\").\nConsider these rules ideals for new code, opportunities to exploit when working on older code, and try to approximate these ideals as closely as feasible.\nRemember:\n\n### <a name=\"r0\"></a>In.0: Don't panic!\n\nTake the time to understand the implications of a guideline rule on your program.\n\nThese guidelines are designed according to the \"subset of superset\" principle ([Stroustrup05](#Stroustrup05)).\nThey do not simply define a subset of C++ to be used (for reliability, safety, performance, or whatever).\nInstead, they strongly recommend the use of a few simple \"extensions\" ([library components](#gsl-guidelines-support-library))\nthat make the use of the most error-prone features of C++ redundant, so that they can be banned (in our set of rules).\n\nThe rules emphasize static type safety and resource safety.\nFor that reason, they emphasize possibilities for range checking, for avoiding dereferencing `nullptr`, for avoiding dangling pointers, and the systematic use of exceptions (via RAII).\nPartly to achieve that and partly to minimize obscure code as a source of errors, the rules also emphasize simplicity and the hiding of necessary complexity behind well-specified interfaces.\n\nMany of the rules are prescriptive.\nWe are uncomfortable with rules that simply state \"don't do that!\" without offering an alternative.\nOne consequence of that is that some rules can be supported only by heuristics, rather than precise and mechanically verifiable checks.\nOther rules articulate general principles. For these more general rules, more detailed and specific rules provide partial checking.\n\nThese guidelines address the core of C++ and its use.\nWe expect that most large organizations, specific application areas, and even large projects will need further rules, possibly further restrictions, and further library support.\nFor example, hard-real-time programmers typically can't use free store (dynamic memory) freely and will be restricted in their choice of libraries.\nWe encourage the development of such more specific rules as addenda to these core guidelines.\nBuild your ideal small foundation library and use that, rather than lowering your level of programming to glorified assembly code.\n\nThe rules are designed to allow [gradual adoption](#s-modernizing).\n\nSome rules aim to increase various forms of safety while others aim to reduce the likelihood of accidents, many do both.\nThe guidelines aimed at preventing accidents often ban perfectly legal C++.\nHowever, when there are two ways of expressing an idea and one has shown itself a common source of errors and the other has not, we try to guide programmers towards the latter.\n\n## <a name=\"ss-non\"></a>In.not: Non-aims\n\nThe rules are not intended to be minimal or orthogonal.\nIn particular, general rules can be simple, but unenforceable.\nAlso, it is often hard to understand the implications of a general rule.\nMore specialized rules are often easier to understand and to enforce, but without general rules, they would just be a long list of special cases.\nWe provide rules aimed at helping novices as well as rules supporting expert use.\nSome rules can be completely enforced, but others are based on heuristics.\n\nThese rules are not meant to be read serially, like a book.\nYou can browse through them using the links.\nHowever, their main intended use is to be targets for tools.\nThat is, a tool looks for violations and the tool returns links to violated rules.\nThe rules then provide reasons, examples of potential consequences of the violation, and suggested remedies.\n\nThese guidelines are not intended to be a substitute for a tutorial treatment of C++.\nIf you need a tutorial for some given level of experience, see [the references](#s-references).\n\nThis is not a guide on how to convert old C++ code to more modern code.\nIt is meant to articulate ideas for new code in a concrete fashion.\nHowever, see [the modernization section](#s-modernizing) for some possible approaches to modernizing/rejuvenating/upgrading.\nImportantly, the rules support gradual adoption: It is typically infeasible to completely convert a large code base all at once.\n\nThese guidelines are not meant to be complete or exact in every language-technical detail.\nFor the final word on language definition issues, including every exception to general rules and every feature, see the ISO C++ standard.\n\nThe rules are not intended to force you to write in an impoverished subset of C++.\nThey are *emphatically* not meant to define a, say, Java-like subset of C++.\nThey are not meant to define a single \"one true C++\" language.\nWe value expressiveness and uncompromised performance.\n\nThe rules are not value-neutral.\nThey are meant to make code simpler and more correct/safer than most existing C++ code, without loss of performance.\nThey are meant to inhibit perfectly valid C++ code that correlates with errors, spurious complexity, and poor performance.\n\nThe rules are not precise to the point where a person (or machine) can follow them without thinking.\nThe enforcement parts try to be that, but we would rather leave a rule or a definition a bit vague\nand open to interpretation than specify something precisely and wrong.\nSometimes, precision comes only with time and experience.\nDesign is not (yet) a form of Math.\n\nThe rules are not perfect.\nA rule can do harm by prohibiting something that is useful in a given situation.\nA rule can do harm by failing to prohibit something that enables a serious error in a given situation.\nA rule can do a lot of harm by being vague, ambiguous, unenforceable, or by enabling every solution to a problem.\nIt is impossible to completely meet the \"do no harm\" criteria.\nInstead, our aim is the less ambitious: \"Do the most good for most programmers\";\nif you cannot live with a rule, object to it, ignore it, but don't water it down until it becomes meaningless.\nAlso, suggest an improvement.\n\n## <a name=\"ss-force\"></a>In.force: Enforcement\n\nRules with no enforcement are unmanageable for large code bases.\nEnforcement of all rules is possible only for a small weak set of rules or for a specific user community.\n\n* But we want lots of rules, and we want rules that everybody can use.\n* But different people have different needs.\n* But people don't like to read lots of rules.\n* But people can't remember many rules.\n\nSo, we need subsetting to meet a variety of needs.\n\n* But arbitrary subsetting leads to chaos.\n\nWe want guidelines that help a lot of people, make code more uniform, and strongly encourage people to modernize their code.\nWe want to encourage best practices, rather than leave all to individual choices and management pressures.\nThe ideal is to use all rules; that gives the greatest benefits.\n\nThis adds up to quite a few dilemmas.\nWe try to resolve those using tools.\nEach rule has an **Enforcement** section listing ideas for enforcement.\nEnforcement might be done by code review, by static analysis, by compiler, or by run-time checks.\nWherever possible, we prefer \"mechanical\" checking (humans are slow, inaccurate, and bore easily) and static checking.\nRun-time checks are suggested only rarely where no alternative exists; we do not want to introduce \"distributed bloat\".\nWhere appropriate, we label a rule (in the **Enforcement** sections) with the name of groups of related rules (called \"profiles\").\nA rule can be part of several profiles, or none.\nFor a start, we have a few profiles corresponding to common needs (desires, ideals):\n\n* **type**: No type violations (reinterpreting a `T` as a `U` through casts, unions, or varargs)\n* **bounds**: No bounds violations (accessing beyond the range of an array)\n* **lifetime**: No leaks (failing to `delete` or multiple `delete`) and no access to invalid objects (dereferencing `nullptr`, using a dangling reference).\n\nThe profiles are intended to be used by tools, but also serve as an aid to the human reader.\nWe do not limit our comment in the **Enforcement** sections to things we know how to enforce; some comments are mere wishes that might inspire some tool builder.\n\nTools that implement these rules shall respect the following syntax to explicitly suppress a rule:\n\n    [[gsl::suppress(\"tag\")]]\n\nand optionally with a message (following usual C++11 standard attribute syntax):\n\n    [[gsl::suppress(\"tag\", justification: \"message\")]]\n\nwhere\n\n* `\"tag\"` is a string literal with the anchor name of the item where the Enforcement rule appears (e.g., for [C.134](#rh-public) it is \"rh-public\"), the\nname of a profile group-of-rules (\"type\", \"bounds\", or \"lifetime\"),\nor a specific rule in a profile ([type.4](#pro-type-cstylecast), or [bounds.2](#pro-bounds-arrayindex)). Any text that is not one of those should be rejected.\n\n* `\"message\"` is a string literal\n\n## <a name=\"ss-struct\"></a>In.struct: The structure of this document\n\nEach rule (guideline, suggestion) can have several parts:\n\n* The rule itself -- e.g., **no naked `new`**\n* A rule reference number -- e.g., **C.7** (the 7th rule related to classes).\n  Since the major sections are not inherently ordered, we use letters as the first part of a rule reference \"number\".\n  We leave gaps in the numbering to minimize \"disruption\" when we add or remove rules.\n* **Reason**s (rationales) -- because programmers find it hard to follow rules they don't understand\n* **Example**s -- because rules are hard to understand in the abstract; can be positive or negative\n* **Alternative**s -- for \"don't do this\" rules\n* **Exception**s -- we prefer simple general rules. However, many rules apply widely, but not universally, so exceptions must be listed\n* **Enforcement** -- ideas about how the rule might be checked \"mechanically\"\n* **See also**s -- references to related rules and/or further discussion (in this document or elsewhere)\n* **Note**s (comments) -- something that needs saying that doesn't fit the other classifications\n* **Discussion** -- references to more extensive rationale and/or examples placed outside the main lists of rules\n\nSome rules are hard to check mechanically, but they all meet the minimal criteria that an expert programmer can spot many violations without too much trouble.\nWe hope that \"mechanical\" tools will improve with time to approximate what such an expert programmer notices.\nAlso, we assume that the rules will be refined over time to make them more precise and checkable.\n\nA rule is aimed at being simple, rather than carefully phrased to mention every alternative and special case.\nSuch information is found in the **Alternative** paragraphs and the [Discussion](#s-discussion) sections.\nIf you don't understand a rule or disagree with it, please visit its **Discussion**.\nIf you feel that a discussion is missing or incomplete, enter an [Issue](https://github.com/isocpp/CppCoreGuidelines/issues)\nexplaining your concerns and possibly a corresponding PR.\n\nExamples are written to illustrate rules.\n\n* Examples are not intended to be production quality or to cover all tutorial dimensions.\nFor example, many examples are language-technical and use names like `f`, `base`, and `x`.\n* We try to ensure that \"good\" examples follow the Core Guidelines.\n* Comments are often illustrating rules where they would be unnecessary and/or distracting in \"real code.\"\n* We assume knowledge of the standard library. For example, we use plain `vector` rather than `std::vector`.\n\nThis is not a language manual.\nIt is meant to be helpful, rather than complete, fully accurate on technical details, or a guide to existing code.\nRecommended information sources can be found in [the references](#s-references).\n\n## <a name=\"ss-sec\"></a>In.sec: Major sections\n\n* [In: Introduction](#s-introduction)\n* [P: Philosophy](#s-philosophy)\n* [I: Interfaces](#s-interfaces)\n* [F: Functions](#s-functions)\n* [C: Classes and class hierarchies](#s-class)\n* [Enum: Enumerations](#s-enum)\n* [R: Resource management](#s-resource)\n* [ES: Expressions and statements](#s-expr)\n* [Per: Performance](#s-performance)\n* [CP: Concurrency and parallelism](#s-concurrency)\n* [E: Error handling](#s-errors)\n* [Con: Constants and immutability](#s-const)\n* [T: Templates and generic programming](#s-templates)\n* [CPL: C-style programming](#s-cpl)\n* [SF: Source files](#s-source)\n* [SL: The Standard Library](#sl-the-standard-library)\n\nSupporting sections:\n\n* [A: Architectural ideas](#s-a)\n* [NR: Non-Rules and myths](#s-not)\n* [RF: References](#s-references)\n* [Pro: Profiles](#s-profile)\n* [GSL: Guidelines support library](#gsl-guidelines-support-library)\n* [NL: Naming and layout suggestions](#s-naming)\n* [FAQ: Answers to frequently asked questions](#s-faq)\n* [Appendix A: Libraries](#s-libraries)\n* [Appendix B: Modernizing code](#s-modernizing)\n* [Appendix C: Discussion](#s-discussion)\n* [Appendix D: Supporting tools](#s-tools)\n* [Glossary](#s-glossary)\n* [To-do: Unclassified proto-rules](#s-unclassified)\n\nThese sections are not orthogonal.\n\nEach section (e.g., \"P\" for \"Philosophy\") and each subsection (e.g., \"C.hier\" for \"Class Hierarchies (OOP)\") have an abbreviation for ease of searching and reference.\nThe main section abbreviations are also used in rule numbers (e.g., \"C.11\" for \"Make concrete types regular\").\n\n# <a name=\"s-philosophy\"></a>P: Philosophy\n\nThe rules in this section are very general.\n\nPhilosophy rules summary:\n\n* [P.1: Express ideas directly in code](#rp-direct)\n* [P.2: Write in ISO Standard C++](#rp-cplusplus)\n* [P.3: Express intent](#rp-what)\n* [P.4: Ideally, a program should be statically type safe](#rp-typesafe)\n* [P.5: Prefer compile-time checking to run-time checking](#rp-compile-time)\n* [P.6: What cannot be checked at compile time should be checkable at run time](#rp-run-time)\n* [P.7: Catch run-time errors early](#rp-early)\n* [P.8: Don't leak any resources](#rp-leak)\n* [P.9: Don't waste time or space](#rp-waste)\n* [P.10: Prefer immutable data to mutable data](#rp-mutable)\n* [P.11: Encapsulate messy constructs, rather than spreading through the code](#rp-library)\n* [P.12: Use supporting tools as appropriate](#rp-tools)\n* [P.13: Use support libraries as appropriate](#rp-lib)\n\nPhilosophical rules are generally not mechanically checkable.\nHowever, individual rules reflecting these philosophical themes are.\nWithout a philosophical basis, the more concrete/specific/checkable rules lack rationale.\n\n### <a name=\"rp-direct\"></a>P.1: Express ideas directly in code\n\n##### Reason\n\nCompilers don't read comments (or design documents) and neither do many programmers (consistently).\nWhat is expressed in code has defined semantics and can (in principle) be checked by compilers and other tools.\n\n##### Example\n\n    class Date {\n    public:\n        Month month() const;  // do\n        int month();          // don't\n        // ...\n    };\n\nThe first declaration of `month` is explicit about returning a `Month` and about not modifying the state of the `Date` object.\nThe second version leaves the reader guessing and opens more possibilities for uncaught bugs.\n\n##### Example, bad\n\nThis loop is a restricted form of `std::find`:\n\n    void f(vector<string>& v)\n    {\n        string val;\n        cin >> val;\n        // ...\n        int index = -1;                    // bad, plus should use gsl::index\n        for (int i = 0; i < v.size(); ++i) {\n            if (v[i] == val) {\n                index = i;\n                break;\n            }\n        }\n        // ...\n    }\n\n##### Example, good\n\nA much clearer expression of intent would be:\n\n    void f(vector<string>& v)\n    {\n        string val;\n        cin >> val;\n        // ...\n        auto p = find(begin(v), end(v), val);  // better\n        // ...\n    }\n\nA well-designed library expresses intent (what is to be done, rather than just how something is being done) far better than direct use of language features.\n\nA C++ programmer should know the basics of the standard library, and use it where appropriate.\nAny programmer should know the basics of the foundation libraries of the project being worked on, and use them appropriately.\nAny programmer using these guidelines should know the [guidelines support library](#gsl-guidelines-support-library), and use it appropriately.\n\n##### Example\n\n    change_speed(double s);   // bad: what does s signify?\n    // ...\n    change_speed(2.3);\n\nA better approach is to be explicit about the meaning of the double (new speed or delta on old speed?) and the unit used:\n\n    change_speed(Speed s);    // better: the meaning of s is specified\n    // ...\n    change_speed(2.3);        // error: no unit\n    change_speed(23_m / 10s);  // meters per second\n\nWe could have accepted a plain (unit-less) `double` as a delta, but that would have been error-prone.\nIf we wanted both absolute speed and deltas, we would have defined a `Delta` type.\n\n##### Enforcement\n\nVery hard in general.\n\n* use `const` consistently (check if member functions modify their object; check if functions modify arguments passed by pointer or reference)\n* flag uses of casts (casts neuter the type system)\n* detect code that mimics the standard library (hard)\n\n### <a name=\"rp-cplusplus\"></a>P.2: Write in ISO Standard C++\n\n##### Reason\n\nThis is a set of guidelines for writing ISO Standard C++.\n\n##### Note\n\nThere are environments where extensions are necessary, e.g., to access system resources.\nIn such cases, localize the use of necessary extensions and control their use with non-core Coding Guidelines.  If possible, build interfaces that encapsulate the extensions so they can be turned off or compiled away on systems that do not support those extensions.\n\nExtensions often do not have rigorously defined semantics.  Even extensions that\nare common and implemented by multiple compilers might have slightly different\nbehaviors and edge case behavior as a direct result of *not* having a rigorous\nstandard definition.  With sufficient use of any such extension, expected\nportability will be impacted.\n\n##### Note\n\nUsing valid ISO C++ does not guarantee portability (let alone correctness).\nAvoid dependence on undefined behavior (e.g., [undefined order of evaluation](#res-order))\nand be aware of constructs with implementation defined meaning (e.g., `sizeof(int)`).\n\n##### Note\n\nThere are environments where restrictions on use of standard C++ language or library features are necessary, e.g., to avoid dynamic memory allocation as required by aircraft control software standards.\nIn such cases, control their (dis)use with an extension of these Coding Guidelines customized to the specific environment.\n\n##### Enforcement\n\nUse an up-to-date C++ compiler (currently C++20 or C++17) with a set of options that do not accept extensions.\n\n### <a name=\"rp-what\"></a>P.3: Express intent\n\n##### Reason\n\nUnless the intent of some code is stated (e.g., in names or comments), it is impossible to tell whether the code does what it is supposed to do.\n\n##### Example\n\n    gsl::index i = 0;\n    while (i < v.size()) {\n        // ... do something with v[i] ...\n    }\n\nThe intent of \"just\" looping over the elements of `v` is not expressed here. The implementation detail of an index is exposed (so that it might be misused), and `i` outlives the scope of the loop, which might or might not be intended. The reader cannot know from just this section of code.\n\nBetter:\n\n    for (const auto& x : v) { /* do something with the value of x */ }\n\nNow, there is no explicit mention of the iteration mechanism, and the loop operates on a reference to `const` elements so that accidental modification cannot happen. If modification is desired, say so:\n\n    for (auto& x : v) { /* modify x */ }\n\nFor more details about for-statements, see [ES.71](#res-for-range).\nSometimes better still, use a named algorithm. This example uses the `for_each` from the Ranges TS because it directly expresses the intent:\n\n    for_each(v, [](int x) { /* do something with the value of x */ });\n    for_each(par, v, [](int x) { /* do something with the value of x */ });\n\nThe last variant makes it clear that we are not interested in the order in which the elements of `v` are handled.\n\nA programmer should be familiar with\n\n* [The guidelines support library](#gsl-guidelines-support-library)\n* [The ISO C++ Standard Library](#sl-the-standard-library)\n* Whatever foundation libraries are used for the current project(s)\n\n##### Note\n\nAlternative formulation: Say what should be done, rather than just how it should be done.\n\n##### Note\n\nSome language constructs express intent better than others.\n\n##### Example\n\nIf two `int`s are meant to be the coordinates of a 2D point, say so:\n\n    draw_line(int, int, int, int);  // obscure: (x1,y1,x2,y2)? (x,y,h,w)? ...?\n                                    // need to look up documentation to know\n\n    draw_line(Point, Point);        // clearer\n\n##### Enforcement\n\nLook for common patterns for which there are better alternatives\n\n* simple `for` loops vs. range-`for` loops\n* `f(T*, int)` interfaces vs. `f(span<T>)` interfaces\n* loop variables in too large a scope\n* naked `new` and `delete`\n* functions with many parameters of built-in types\n\nThere is a huge scope for cleverness and semi-automated program transformation.\n\n### <a name=\"rp-typesafe\"></a>P.4: Ideally, a program should be statically type safe\n\n##### Reason\n\nIdeally, a program would be completely statically (compile-time) type safe.\nUnfortunately, that is not possible. Problem areas:\n\n* unions\n* casts\n* array decay\n* range errors\n* narrowing conversions\n\n##### Note\n\nThese areas are sources of serious problems (e.g., crashes and security violations).\nWe try to provide alternative techniques.\n\n##### Enforcement\n\nWe can ban, restrain, or detect the individual problem categories separately, as required and feasible for individual programs.\nAlways suggest an alternative.\nFor example:\n\n* unions -- use `variant` (in C++17)\n* casts -- minimize their use; templates can help\n* array decay -- use `span` (from the GSL)\n* range errors -- use `span`\n* narrowing conversions -- minimize their use and use `narrow` or `narrow_cast` (from the GSL) where they are necessary\n\n### <a name=\"rp-compile-time\"></a>P.5: Prefer compile-time checking to run-time checking\n\n##### Reason\n\nCode clarity and performance.\nYou don't need to write error handlers for errors caught at compile time.\n\n##### Example\n\n    // Int is an alias used for integers\n    int bits = 0;         // don't: avoidable code\n    for (Int i = 1; i; i <<= 1)\n        ++bits;\n    if (bits < 32)\n        cerr << \"Int too small\\n\";\n\nThis example fails to achieve what it is trying to achieve (because overflow is undefined) and should be replaced with a simple `static_assert`:\n\n    // Int is an alias used for integers\n    static_assert(sizeof(Int) >= 4);    // do: compile-time check\n\nOr better still just use the type system and replace `Int` with `int32_t`.\n\n##### Example\n\n    void read(int* p, int n);   // read max n integers into *p\n\n    int a[100];\n    read(a, 1000);    // bad, off the end\n\nbetter\n\n    void read(span<int> r); // read into the range of integers r\n\n    int a[100];\n    read(a);        // better: let the compiler figure out the number of elements\n\n**Alternative formulation**: Don't postpone to run time what can be done well at compile time.\n\n##### Enforcement\n\n* Look for pointer arguments.\n* Look for run-time checks for range violations.\n\n### <a name=\"rp-run-time\"></a>P.6: What cannot be checked at compile time should be checkable at run time\n\n##### Reason\n\nLeaving hard-to-detect errors in a program is asking for crashes and bad results.\n\n##### Note\n\nIdeally, we catch all errors (that are not errors in the programmer's logic) at either compile time or run time. It is impossible to catch all errors at compile time and often not affordable to catch all remaining errors at run time. However, we should endeavor to write programs that in principle can be checked, given sufficient resources (analysis programs, run-time checks, machine resources, time).\n\n##### Example, bad\n\n    // separately compiled, possibly dynamically loaded\n    extern void f(int* p);\n\n    void g(int n)\n    {\n        // bad: the number of elements is not passed to f()\n        f(new int[n]);\n    }\n\nHere, a crucial bit of information (the number of elements) has been so thoroughly \"obscured\" that static analysis is probably rendered infeasible and dynamic checking can be very difficult when `f()` is part of an ABI so that we cannot \"instrument\" that pointer. We could embed helpful information into the free store, but that requires global changes to a system and maybe to the compiler. What we have here is a design that makes error detection very hard.\n\n##### Example, bad\n\nWe can of course pass the number of elements along with the pointer:\n\n    // separately compiled, possibly dynamically loaded\n    extern void f2(int* p, int n);\n\n    void g2(int n)\n    {\n        // bad: the wrong number of elements can be passed to f2()\n        f2(new int[n], n);\n    }\n\nPassing the number of elements as an argument is better (and far more common) than just passing the pointer and relying on some (unstated) convention for knowing or discovering the number of elements. However (as shown), a simple typo can introduce a serious error. The connection between the two arguments of `f2()` is conventional, rather than explicit.\n\nAlso, it is implicit that `f2()` is supposed to `delete` its argument (or did the caller make a second mistake?).\n\n##### Example, bad\n\nThe standard library resource management pointers fail to pass the size when they point to an object:\n\n    // separately compiled, possibly dynamically loaded\n    // NB: this assumes the calling code is ABI-compatible, using a\n    // compatible C++ compiler and the same stdlib implementation\n    extern void f3(unique_ptr<int[]>, int n);\n\n    void g3(int n)\n    {\n        f3(make_unique<int[]>(n), m);    // bad: pass ownership and size separately\n    }\n\n##### Example\n\nWe need to pass the pointer and the number of elements as an integral object:\n\n    extern void f4(vector<int>&);   // separately compiled, possibly dynamically loaded\n    extern void f4(span<int>);      // separately compiled, possibly dynamically loaded\n                                    // NB: this assumes the calling code is ABI-compatible, using a\n                                    // compatible C++ compiler and the same stdlib implementation\n\n    void g3(int n)\n    {\n        vector<int> v(n);\n        f4(v);                     // pass a reference, retain ownership\n        f4(span<int>{v});          // pass a view, retain ownership\n    }\n\nThis design carries the number of elements along as an integral part of an object, so that errors are unlikely and dynamic (run-time) checking is always feasible, if not always affordable.\n\n##### Example\n\nHow do we transfer both ownership and all information needed for validating use?\n\n    vector<int> f5(int n)    // OK: move\n    {\n        vector<int> v(n);\n        // ... initialize v ...\n        return v;\n    }\n\n    unique_ptr<int[]> f6(int n)    // bad: loses n\n    {\n        auto p = make_unique<int[]>(n);\n        // ... initialize *p ...\n        return p;\n    }\n\n    owner<int*> f7(int n)    // bad: loses n and we might forget to delete\n    {\n        owner<int*> p = new int[n];\n        // ... initialize *p ...\n        return p;\n    }\n\n##### Example\n\n* ???\n* show how possible checks are avoided by interfaces that pass polymorphic base classes around, when they actually know what they need?\n  Or strings as \"free-style\" options\n\n##### Enforcement\n\n* Flag (pointer, count)-style interfaces (this will flag a lot of examples that can't be fixed for compatibility reasons)\n* ???\n\n### <a name=\"rp-early\"></a>P.7: Catch run-time errors early\n\n##### Reason\n\nAvoid \"mysterious\" crashes.\nAvoid errors leading to (possibly unrecognized) wrong results.\n\n##### Example\n\n    void increment1(int* p, int n)    // bad: error-prone\n    {\n        for (int i = 0; i < n; ++i) ++p[i];\n    }\n\n    void use1(int m)\n    {\n        const int n = 10;\n        int a[n] = {};\n        // ...\n        increment1(a, m);   // maybe typo, maybe m <= n is supposed\n                            // but assume that m == 20\n        // ...\n    }\n\nHere we made a small error in `use1` that will lead to corrupted data or a crash.\nThe (pointer, count)-style interface leaves `increment1()` with no realistic way of defending itself against out-of-range errors.\nIf we could check subscripts for out of range access, then the error would not be discovered until `p[10]` was accessed.\nWe could check earlier and improve the code:\n\n    void increment2(span<int> p)\n    {\n        for (int& x : p) ++x;\n    }\n\n    void use2(int m)\n    {\n        const int n = 10;\n        int a[n] = {};\n        // ...\n        increment2({a, m});    // maybe typo, maybe m <= n is supposed\n        // ...\n    }\n\nNow, `m <= n` can be checked at the point of call (early) rather than later.\nIf all we had was a typo so that we meant to use `n` as the bound, the code could be further simplified (eliminating the possibility of an error):\n\n    void use3(int m)\n    {\n        const int n = 10;\n        int a[n] = {};\n        // ...\n        increment2(a);   // the number of elements of a need not be repeated\n        // ...\n    }\n\n##### Example, bad\n\nDon't repeatedly check the same value. Don't pass structured data as strings:\n\n    Date read_date(istream& is);    // read date from istream\n\n    Date extract_date(const string& s);    // extract date from string\n\n    void user1(const string& date)    // manipulate date\n    {\n        auto d = extract_date(date);\n        // ...\n    }\n\n    void user2()\n    {\n        Date d = read_date(cin);\n        // ...\n        user1(d.to_string());\n        // ...\n    }\n\nThe date is validated twice (by the `Date` constructor) and passed as a character string (unstructured data).\n\n##### Example\n\nExcess checking can be costly.\nThere are cases where checking early is inefficient because you might never need the value, or might only need part of the value that is more easily checked than the whole.  Similarly, don't add validity checks that change the asymptotic behavior of your interface (e.g., don't add a `O(n)` check to an interface with an average complexity of `O(1)`).\n\n    class Jet {    // Physics says: e * e < x * x + y * y + z * z\n        float x;\n        float y;\n        float z;\n        float e;\n    public:\n        Jet(float x, float y, float z, float e)\n            :x(x), y(y), z(z), e(e)\n        {\n            // Should I check here that the values are physically meaningful?\n        }\n\n        float m() const\n        {\n            // Should I handle the degenerate case here?\n            return sqrt(x * x + y * y + z * z - e * e);\n        }\n\n        ???\n    };\n\nThe physical law for a jet (`e * e < x * x + y * y + z * z`) is not an invariant because of the possibility for measurement errors.\n\n???\n\n##### Enforcement\n\n* Look at pointers and arrays: Do range-checking early and not repeatedly\n* Look at conversions: Eliminate or mark narrowing conversions\n* Look for unchecked values coming from input\n* Look for structured data (objects of classes with invariants) being converted into strings\n* ???\n\n### <a name=\"rp-leak\"></a>P.8: Don't leak any resources\n\n##### Reason\n\nEven a slow growth in resources will, over time, exhaust the availability of those resources.\nThis is particularly important for long-running programs, but is an essential piece of responsible programming behavior.\n\n##### Example, bad\n\n    void f(const char* name)\n    {\n        FILE* input = fopen(name, \"r\");\n        // ...\n        if (something) return;   // bad: if something == true, a file handle is leaked\n        // ...\n        fclose(input);\n    }\n\nPrefer [RAII](#rr-raii):\n\n    void f(const char* name)\n    {\n        ifstream input {name};\n        // ...\n        if (something) return;   // OK: no leak\n        // ...\n    }\n\n**See also**: [The resource management section](#s-resource)\n\n##### Note\n\nA leak is colloquially \"anything that isn't cleaned up.\"\nThe more important classification is \"anything that can no longer be cleaned up.\"\nFor example, allocating an object on the heap and then losing the last pointer that points to that allocation.\nThis rule should not be taken as requiring that allocations within long-lived objects must be returned during program shutdown.\nFor example, relying on system guaranteed cleanup such as file closing and memory deallocation upon process shutdown can simplify code.\nHowever, relying on abstractions that implicitly clean up can be as simple, and often safer.\n\n##### Note\n\nEnforcing [the lifetime safety profile](#ss-lifetime) eliminates leaks.\nWhen combined with resource safety provided by [RAII](#rr-raii), it eliminates the need for \"garbage collection\" (by generating no garbage).\nCombine this with enforcement of [the type and bounds profiles](#ss-force) and you get complete type- and resource-safety, guaranteed by tools.\n\n##### Enforcement\n\n* Look at pointers: Classify them into non-owners (the default) and owners.\n  Where feasible, replace owners with standard-library resource handles (as in the example above).\n  Alternatively, mark an owner as such using `owner` from [the GSL](#gsl-guidelines-support-library).\n* Look for naked `new` and `delete`\n* Look for known resource allocating functions returning raw pointers (such as `fopen`, `malloc`, and `strdup`)\n\n### <a name=\"rp-waste\"></a>P.9: Don't waste time or space\n\n##### Reason\n\nThis is C++.\n\n##### Note\n\nTime and space that you spend well to achieve a goal (e.g., speed of development, resource safety, or simplification of testing) is not wasted.\n\"Another benefit of striving for efficiency is that the process forces you to understand the problem in more depth.\" - Alex Stepanov\n\n##### Example, bad\n\n    struct X {\n        char ch;\n        int i;\n        string s;\n        char ch2;\n\n        X& operator=(const X& a);\n        X(const X&);\n    };\n\n    X waste(const char* p)\n    {\n        if (!p) throw Nullptr_error{};\n        int n = strlen(p);\n        auto buf = new char[n];\n        if (!buf) throw Allocation_error{};\n        for (int i = 0; i < n; ++i) buf[i] = p[i];\n        // ... manipulate buffer ...\n        X x;\n        x.ch = 'a';\n        x.s = string(n);    // give x.s space for *p\n        for (gsl::index i = 0; i < x.s.size(); ++i) x.s[i] = buf[i];  // copy buf into x.s\n        delete[] buf;\n        return x;\n    }\n\n    void driver()\n    {\n        X x = waste(\"Typical argument\");\n        // ...\n    }\n\nYes, this is a caricature, but we have seen every individual mistake in production code, and worse.\nNote that the layout of `X` guarantees that at least 6 bytes (and most likely more) are wasted.\nThe spurious definition of copy operations disables move semantics so that the return operation is slow\n(please note that the Return Value Optimization, RVO, is not guaranteed here).\nThe use of `new` and `delete` for `buf` is redundant; if we really needed a local string, we should use a local `string`.\nThere are several more performance bugs and gratuitous complication.\n\n##### Example, bad\n\n    void lower(zstring s)\n    {\n        for (int i = 0; i < strlen(s); ++i) s[i] = tolower(s[i]);\n    }\n\nThis is actually an example from production code.\nWe can see that in our condition we have `i < strlen(s)`. This expression will be evaluated on every iteration of the loop, which means that `strlen` must walk through string every loop to discover its length. While the string contents are changing, it's assumed that `tolower` will not affect the length of the string, so it's better to cache the length outside the loop and not incur that cost each iteration.\n\n##### Note\n\nAn individual example of waste is rarely significant, and where it is significant, it is typically easily eliminated by an expert.\nHowever, waste spread liberally across a code base can easily be significant and experts are not always as available as we would like.\nThe aim of this rule (and the more specific rules that support it) is to eliminate most waste related to the use of C++ before it happens.\nAfter that, we can look at waste related to algorithms and requirements, but that is beyond the scope of these guidelines.\n\n##### Enforcement\n\nMany more specific rules aim at the overall goals of simplicity and elimination of gratuitous waste.\n\n* Flag an unused return value from a user-defined non-defaulted postfix `operator++` or `operator--` function. Prefer using the prefix form instead. (Note: \"User-defined non-defaulted\" is intended to reduce noise. Review this enforcement if it's still too noisy in practice.)\n\n\n### <a name=\"rp-mutable\"></a>P.10: Prefer immutable data to mutable data\n\n##### Reason\n\nIt is easier to reason about constants than about variables.\nSomething immutable cannot change unexpectedly.\nSometimes immutability enables better optimization.\nYou can't have a data race on a constant.\n\nSee [Con: Constants and immutability](#s-const)\n\n### <a name=\"rp-library\"></a>P.11: Encapsulate messy constructs, rather than spreading through the code\n\n##### Reason\n\nMessy code is more likely to hide bugs and harder to write.\nA good interface is easier and safer to use.\nMessy, low-level code breeds more such code.\n\n##### Example\n\n    int sz = 100;\n    int* p = (int*) malloc(sizeof(int) * sz);\n    int count = 0;\n    // ...\n    for (;;) {\n        // ... read an int into x, exit loop if end of file is reached ...\n        // ... check that x is valid ...\n        if (count == sz)\n            p = (int*) realloc(p, sizeof(int) * sz * 2);\n        p[count++] = x;\n        // ...\n    }\n\nThis is low-level, verbose, and error-prone.\nFor example, we \"forgot\" to test for memory exhaustion and assign new value to `sz`.\nInstead, we could use `vector`:\n\n    vector<int> v;\n    v.reserve(100);\n    // ...\n    for (int x; cin >> x; ) {\n        // ... check that x is valid ...\n        v.push_back(x);\n    }\n\n##### Note\n\nThe standards library and the GSL are examples of this philosophy.\nFor example, instead of messing with the arrays, unions, cast, tricky lifetime issues, `gsl::owner`, etc.,\nthat are needed to implement key abstractions, such as `vector`, `span`, `lock_guard`, and `future`, we use the libraries\ndesigned and implemented by people with more time and expertise than we usually have.\nSimilarly, we can and should design and implement more specialized libraries, rather than leaving the users (often ourselves)\nwith the challenge of repeatedly getting low-level code well.\nThis is a variant of the [subset of superset principle](#r0) that underlies these guidelines.\n\n##### Enforcement\n\n* Look for \"messy code\" such as complex pointer manipulation and casting outside the implementation of abstractions.\n\n\n### <a name=\"rp-tools\"></a>P.12: Use supporting tools as appropriate\n\n##### Reason\n\nThere are many things that are done better \"by machine\".\nComputers don't tire or get bored by repetitive tasks.\nWe typically have better things to do than repeatedly do routine tasks.\n\n##### Example\n\nRun a static analyzer to verify that your code follows the guidelines you want it to follow.\n\n##### Note\n\nSee\n\n* [Static analysis tools](https://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis)\n* [Concurrency tools](#rconc-tools)\n* [Testing tools](https://github.com/isocpp/CppCoreGuidelines/tree/master)\n\nThere are many other kinds of tools, such as source code repositories, build tools, etc.,\nbut those are beyond the scope of these guidelines.\n\n##### Note\n\nBe careful not to become dependent on over-elaborate or over-specialized tool chains.\nThose can make your otherwise portable code non-portable.\n\n\n### <a name=\"rp-lib\"></a>P.13: Use support libraries as appropriate\n\n##### Reason\n\nUsing a well-designed, well-documented, and well-supported library saves time and effort;\nits quality and documentation are likely to be greater than what you could do\nif the majority of your time must be spent on an implementation.\nThe cost (time, effort, money, etc.) of a library can be shared over many users.\nA widely used library is more likely to be kept up-to-date and ported to new systems than an individual application.\nKnowledge of a widely-used library can save time on other/future projects.\nSo, if a suitable library exists for your application domain, use it.\n\n##### Example\n\n    std::sort(begin(v), end(v), std::greater<>());\n\nUnless you are an expert in sorting algorithms and have plenty of time,\nthis is more likely to be correct and to run faster than anything you write for a specific application.\nYou need a reason not to use the standard library (or whatever foundational libraries your application uses) rather than a reason to use it.\n\n##### Note\n\nBy default use\n\n* The [ISO C++ Standard Library](#sl-the-standard-library)\n* The [Guidelines Support Library](#gsl-guidelines-support-library)\n\n##### Note\n\nIf no well-designed, well-documented, and well-supported library exists for an important domain,\nmaybe you should design and implement it, and then use it.\n\n\n# <a name=\"s-interfaces\"></a>I: Interfaces\n\nAn interface is a contract between two parts of a program. Precisely stating what is expected of a supplier of a service and a user of that service is essential.\nHaving good (easy-to-understand, encouraging efficient use, not error-prone, supporting testing, etc.) interfaces is probably the most important single aspect of code organization.\n\nInterface rule summary:\n\n* [I.1: Make interfaces explicit](#ri-explicit)\n* [I.2: Avoid non-`const` global variables](#ri-global)\n* [I.3: Avoid singletons](#ri-singleton)\n* [I.4: Make interfaces precisely and strongly typed](#ri-typed)\n* [I.5: State preconditions (if any)](#ri-pre)\n* [I.6: Prefer `Expects()` for expressing preconditions](#ri-expects)\n* [I.7: State postconditions](#ri-post)\n* [I.8: Prefer `Ensures()` for expressing postconditions](#ri-ensures)\n* [I.9: If an interface is a template, document its parameters using concepts](#ri-concepts)\n* [I.10: Use exceptions to signal a failure to perform a required task](#ri-except)\n* [I.11: Never transfer ownership by a raw pointer (`T*`) or reference (`T&`)](#ri-raw)\n* [I.12: Declare a pointer that must not be null as `not_null`](#ri-nullptr)\n* [I.13: Do not pass an array as a single pointer](#ri-array)\n* [I.22: Avoid complex initialization of global objects](#ri-global-init)\n* [I.23: Keep the number of function arguments low](#ri-nargs)\n* [I.24: Avoid adjacent parameters that can be invoked by the same arguments in either order with different meaning](#ri-unrelated)\n* [I.25: Prefer empty abstract classes as interfaces to class hierarchies](#ri-abstract)\n* [I.26: If you want a cross-compiler ABI, use a C-style subset](#ri-abi)\n* [I.27: For stable library ABI, consider the Pimpl idiom](#ri-pimpl)\n* [I.30: Encapsulate rule violations](#ri-encapsulate)\n\n**See also**:\n\n* [F: Functions](#s-functions)\n* [C.concrete: Concrete types](#ss-concrete)\n* [C.hier: Class hierarchies](#ss-hier)\n* [C.over: Overloading and overloaded operators](#ss-overload)\n* [C.con: Containers and other resource handles](#ss-containers)\n* [E: Error handling](#s-errors)\n* [T: Templates and generic programming](#s-templates)\n\n### <a name=\"ri-explicit\"></a>I.1: Make interfaces explicit\n\n##### Reason\n\nCorrectness. Assumptions not stated in an interface are easily overlooked and hard to test.\n\n##### Example, bad\n\nControlling the behavior of a function through a global (namespace scope) variable (a call mode) is implicit and potentially confusing. For example:\n\n    int round(double d)\n    {\n        return (round_up) ? ceil(d) : d;    // don't: \"invisible\" dependency\n    }\n\nIt will not be obvious to a caller that the meaning of two calls of `round(7.2)` might give different results.\n\n##### Exception\n\nSometimes we control the details of a set of operations by an environment variable, e.g., normal vs. verbose output or debug vs. optimized.\nThe use of a non-local control is potentially confusing, but controls only implementation details of otherwise fixed semantics.\n\n##### Example, bad\n\nReporting through non-local variables (e.g., `errno`) is easily ignored. For example:\n\n    // don't: no test of fprintf's return value\n    fprintf(connection, \"logging: %d %d %d\\n\", x, y, s);\n\nWhat if the connection goes down so that no logging output is produced? See I.???.\n\n**Alternative**: Throw an exception. An exception cannot be ignored.\n\n**Alternative formulation**: Avoid passing information across an interface through non-local or implicit state.\nNote that non-`const` member functions pass information to other member functions through their object's state.\n\n**Alternative formulation**: An interface should be a function or a set of functions.\nFunctions can be function templates and sets of functions can be classes or class templates.\n\n##### Enforcement\n\n* (Simple) A function should not make control-flow decisions based on the values of variables declared at namespace scope.\n* (Simple) A function should not write to variables declared at namespace scope.\n\n### <a name=\"ri-global\"></a>I.2: Avoid non-`const` global variables\n\n##### Reason\n\nNon-`const` global variables hide dependencies and make the dependencies subject to unpredictable changes.\n\n##### Example\n\n    struct Data {\n        // ... lots of stuff ...\n    } data;            // non-const data\n\n    void compute()     // don't\n    {\n        // ... use data ...\n    }\n\n    void output()     // don't\n    {\n        // ... use data ...\n    }\n\nWho else might modify `data`?\n\n**Warning**: The initialization of global objects is not totally ordered.\nIf you use a global object initialize it with a constant.\nNote that it is possible to get undefined initialization order even for `const` objects.\n\n##### Exception\n\nA global object is often better than a singleton.\n\n##### Note\n\nGlobal constants are useful.\n\n##### Note\n\nThe rule against global variables applies to namespace scope variables as well.\n\n**Alternative**: If you use global (more generally namespace scope) data to avoid copying, consider passing the data as an object by reference to `const`.\nAnother solution is to define the data as the state of some object and the operations as member functions.\n\n**Warning**: Beware of data races: If one thread can access non-local data (or data passed by reference) while another thread executes the callee, we can have a data race.\nEvery pointer or reference to mutable data is a potential data race.\n\nUsing global pointers or references to access and change non-const, and otherwise non-global,\ndata isn't a better alternative to non-const global variables since that doesn't solve the issues of hidden dependencies or potential race conditions.\n\n##### Note\n\nYou cannot have a race condition on immutable data.\n\n**References**: See the [rules for calling functions](#ss-call).\n\n##### Note\n\nThe rule is \"avoid\", not \"don't use.\" Of course there will be (rare) exceptions, such as `cin`, `cout`, and `cerr`.\n\n##### Enforcement\n\n(Simple) Report all non-`const` variables declared at namespace scope and global pointers/references to non-const data.\n\n\n### <a name=\"ri-singleton\"></a>I.3: Avoid singletons\n\n##### Reason\n\nSingletons are basically complicated global objects in disguise.\n\n##### Example\n\n    class Singleton {\n        // ... lots of stuff to ensure that only one Singleton object is created,\n        // that it is initialized properly, etc.\n    };\n\nThere are many variants of the singleton idea.\nThat's part of the problem.\n\n##### Note\n\nIf you don't want a global object to change, declare it `const` or `constexpr`.\n\n##### Exception\n\nYou can use the simplest \"singleton\" (so simple that it is often not considered a singleton) to get initialization on first use, if any:\n\n    X& myX()\n    {\n        static X my_x {3};\n        return my_x;\n    }\n\nThis is one of the most effective solutions to problems related to initialization order.\nIn a multi-threaded environment, the initialization of the static object does not introduce a race condition\n(unless you carelessly access a shared object from within its constructor).\n\nNote that the initialization of a local `static` does not imply a race condition.\nHowever, if the destruction of `X` involves an operation that needs to be synchronized we must use a less simple solution.\nFor example:\n\n    X& myX()\n    {\n        static auto p = new X {3};\n        return *p;  // potential leak\n    }\n\nNow someone must `delete` that object in some suitably thread-safe way.\nThat's error-prone, so we don't use that technique unless\n\n* `myX` is in multi-threaded code,\n* that `X` object needs to be destroyed (e.g., because it releases a resource), and\n* `X`'s destructor's code needs to be synchronized.\n\nIf you, as many do, define a singleton as a class for which only one object is created, functions like `myX` are not singletons, and this useful technique is not an exception to the no-singleton rule.\n\n##### Enforcement\n\nVery hard in general.\n\n* Look for classes with names that include `singleton`.\n* Look for classes for which only a single object is created (by counting objects or by examining constructors).\n* If a class X has a public static function that contains a function-local static of the class' type X and returns a pointer or reference to it, ban that.\n\n### <a name=\"ri-typed\"></a>I.4: Make interfaces precisely and strongly typed\n\n##### Reason\n\nTypes are the simplest and best documentation, improve legibility due to their well-defined meaning, and are checked at compile time.\nAlso, precisely typed code is often optimized better.\n\n##### Example, don't\n\nConsider:\n\n    void pass(void* data);    // weak and under-qualified type void* is suspicious\n\nCallers are unsure what types are allowed and if the data may\nbe mutated as `const` is not specified. Note all pointer types\nimplicitly convert to `void*`, so it is easy for callers to provide this value.\n\nThe callee must `static_cast` data to an unverified type to use it.\nThat is error-prone and verbose.\n\nOnly use `const void*` for passing in data in designs that are indescribable in C++. Consider using a `variant` or a pointer to base instead.\n\n**Alternative**: Often, a template parameter can eliminate the `void*` turning it into a `T*` or `T&`.\nFor generic code these `T`s can be general or concept constrained template parameters.\n\n##### Example, bad\n\nConsider:\n\n    draw_rect(100, 200, 100, 500); // what do the numbers specify?\n\n    draw_rect(p.x, p.y, 10, 20); // what units are 10 and 20 in?\n\nIt is clear that the caller is describing a rectangle, but it is unclear what parts they relate to. Also, an `int` can carry arbitrary forms of information, including values of many units, so we must guess about the meaning of the four `int`s. Most likely, the first two are an `x`,`y` coordinate pair, but what are the last two?\n\nComments and parameter names can help, but we could be explicit:\n\n    void draw_rectangle(Point top_left, Point bottom_right);\n    void draw_rectangle(Point top_left, Size height_width);\n\n    draw_rectangle(p, Point{10, 20});  // two corners\n    draw_rectangle(p, Size{10, 20});   // one corner and a (height, width) pair\n\nObviously, we cannot catch all errors through the static type system\n(e.g., the fact that a first argument is supposed to be a top-left point is left to convention (naming and comments)).\n\n##### Example, bad\n\nConsider:\n\n    set_settings(true, false, 42); // what do the numbers specify?\n\nThe parameter types and their values do not communicate what settings are being specified or what those values mean.\n\nThis design is more explicit, safe and legible:\n\n    alarm_settings s{};\n    s.enabled = true;\n    s.displayMode = alarm_settings::mode::spinning_light;\n    s.frequency = alarm_settings::every_10_seconds;\n    set_settings(s);\n\nFor the case of a set of boolean values consider using a flags `enum`; a pattern that expresses a set of boolean values.\n\n    enable_lamp_options(lamp_option::on | lamp_option::animate_state_transitions);\n\n##### Example, bad\n\nIn the following example, it is not clear from the interface what `time_to_blink` means: Seconds? Milliseconds?\n\n    void blink_led(int time_to_blink) // bad -- the unit is ambiguous\n    {\n        // ...\n        // do something with time_to_blink\n        // ...\n    }\n\n    void use()\n    {\n        blink_led(2);\n    }\n\n##### Example, good\n\n`std::chrono::duration` types help making the unit of time duration explicit.\n\n    void blink_led(milliseconds time_to_blink) // good -- the unit is explicit\n    {\n        // ...\n        // do something with time_to_blink\n        // ...\n    }\n\n    void use()\n    {\n        blink_led(1500ms);\n    }\n\nThe function can also be written in such a way that it will accept any time duration unit.\n\n    template<class rep, class period>\n    void blink_led(duration<rep, period> time_to_blink) // good -- accepts any unit\n    {\n        // assuming that millisecond is the smallest relevant unit\n        auto milliseconds_to_blink = duration_cast<milliseconds>(time_to_blink);\n        // ...\n        // do something with milliseconds_to_blink\n        // ...\n    }\n\n    void use()\n    {\n        blink_led(2s);\n        blink_led(1500ms);\n    }\n\n##### Enforcement\n\n* (Simple) Report the use of `void*` as a parameter or return type.\n* (Simple) Report the use of more than one `bool` parameter.\n* (Hard to do well) Look for functions that use too many primitive type arguments.\n\n### <a name=\"ri-pre\"></a>I.5: State preconditions (if any)\n\n##### Reason\n\nArguments have meaning that might constrain their proper use in the callee.\n\n##### Example\n\nConsider:\n\n    double sqrt(double x);\n\nHere `x` must be non-negative. The type system cannot (easily and naturally) express that, so we must use other means. For example:\n\n    double sqrt(double x); // x must be non-negative\n\nSome preconditions can be expressed as assertions. For example:\n\n    double sqrt(double x) { Expects(x >= 0); /* ... */ }\n\nIdeally, that `Expects(x >= 0)` should be part of the interface of `sqrt()` but that's not easily done. For now, we place it in the definition (function body).\n\n**References**: `Expects()` is described in [GSL](#gsl-guidelines-support-library).\n\n##### Note\n\nPrefer a formal specification of requirements, such as `Expects(p);`.\nIf that is infeasible, use English text in comments, such as `// the sequence [p:q) is ordered using <`.\n\n##### Note\n\nMost member functions have as a precondition that some class invariant holds.\nThat invariant is established by a constructor and must be reestablished upon exit by every member function called from outside the class.\nWe don't need to mention it for each member function.\n\n##### Enforcement\n\n(Not enforceable)\n\n**See also**: The rules for passing pointers. ???\n\n### <a name=\"ri-expects\"></a>I.6: Prefer `Expects()` for expressing preconditions\n\n##### Reason\n\nTo make it clear that the condition is a precondition and to enable tool use.\n\n##### Example\n\n    int area(int height, int width)\n    {\n        Expects(height > 0 && width > 0);            // good\n        if (height <= 0 || width <= 0) my_error();   // obscure\n        // ...\n    }\n\n##### Note\n\nPreconditions can be stated in many ways, including comments, `if`-statements, and `assert()`.\nThis can make them hard to distinguish from ordinary code, hard to update, hard to manipulate by tools, and might have the wrong semantics (do you always want to abort in debug mode and check nothing in productions runs?).\n\n##### Note\n\nPreconditions should be part of the interface rather than part of the implementation,\nbut we don't yet have the language facilities to do that.\nOnce language support becomes available (e.g., see the [contract proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0380r1.pdf)) we will adopt the standard version of preconditions, postconditions, and assertions.\n\n##### Note\n\n`Expects()` can also be used to check a condition in the middle of an algorithm.\n\n##### Note\n\nNo, using `unsigned` is not a good way to sidestep the problem of [ensuring that a value is non-negative](#res-nonnegative).\n\n##### Enforcement\n\n(Not enforceable) Finding the variety of ways preconditions can be asserted is not feasible. Warning about those that can be easily identified (`assert()`) has questionable value in the absence of a language facility.\n\n### <a name=\"ri-post\"></a>I.7: State postconditions\n\n##### Reason\n\nTo detect misunderstandings about the result and possibly catch erroneous implementations.\n\n##### Example, bad\n\nConsider:\n\n    int area(int height, int width) { return height * width; }  // bad\n\nHere, we (incautiously) left out the precondition specification, so it is not explicit that height and width must be positive.\nWe also left out the postcondition specification, so it is not obvious that the algorithm (`height * width`) is wrong for areas larger than the largest integer.\nOverflow can happen.\nConsider using:\n\n    int area(int height, int width)\n    {\n        auto res = height * width;\n        Ensures(res > 0);\n        return res;\n    }\n\n##### Example, bad\n\nConsider a famous security bug:\n\n    void f()    // problematic\n    {\n        char buffer[MAX];\n        // ...\n        memset(buffer, 0, sizeof(buffer));\n    }\n\nThere was no postcondition stating that the buffer should be cleared and the optimizer eliminated the apparently redundant `memset()` call:\n\n    void f()    // better\n    {\n        char buffer[MAX];\n        // ...\n        memset(buffer, 0, sizeof(buffer));\n        Ensures(buffer[0] == 0);\n    }\n\n##### Note\n\nPostconditions are often informally stated in a comment that states the purpose of a function; `Ensures()` can be used to make this more systematic, visible, and checkable.\n\n##### Note\n\nPostconditions are especially important when they relate to something that is not directly reflected in a returned result, such as a state of a data structure used.\n\n##### Example\n\nConsider a function that manipulates a `Record`, using a `mutex` to avoid race conditions:\n\n    mutex m;\n\n    void manipulate(Record& r)    // don't\n    {\n        m.lock();\n        // ... no m.unlock() ...\n    }\n\nHere, we \"forgot\" to state that the `mutex` should be released, so we don't know if the failure to ensure release of the `mutex` was a bug or a feature.\nStating the postcondition would have made it clear:\n\n    void manipulate(Record& r)    // postcondition: m is unlocked upon exit\n    {\n        m.lock();\n        // ... no m.unlock() ...\n    }\n\nThe bug is now obvious (but only to a human reading comments).\n\nBetter still, use [RAII](#rr-raii) to ensure that the postcondition (\"the lock must be released\") is enforced in code:\n\n    void manipulate(Record& r)    // best\n    {\n        lock_guard<mutex> _ {m};\n        // ...\n    }\n\n##### Note\n\nIdeally, postconditions are stated in the interface/declaration so that users can easily see them.\nOnly postconditions related to the users can be stated in the interface.\nPostconditions related only to internal state belong in the definition/implementation.\n\n##### Enforcement\n\n(Not enforceable) This is a philosophical guideline that is infeasible to check\ndirectly in the general case. Domain specific checkers (like lock-holding\ncheckers) exist for many toolchains.\n\n### <a name=\"ri-ensures\"></a>I.8: Prefer `Ensures()` for expressing postconditions\n\n##### Reason\n\nTo make it clear that the condition is a postcondition and to enable tool use.\n\n##### Example\n\n    void f()\n    {\n        char buffer[MAX];\n        // ...\n        memset(buffer, 0, MAX);\n        Ensures(buffer[0] == 0);\n    }\n\n##### Note\n\nPostconditions can be stated in many ways, including comments, `if`-statements, and `assert()`.\nThis can make them hard to distinguish from ordinary code, hard to update, hard to manipulate by tools, and might have the wrong semantics.\n\n**Alternative**: Postconditions of the form \"this resource must be released\" are best expressed by [RAII](#rr-raii).\n\n##### Note\n\nIdeally, that `Ensures` should be part of the interface, but that's not easily done.\nFor now, we place it in the definition (function body).\nOnce language support becomes available (e.g., see the [contract proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0380r1.pdf)) we will adopt the standard version of preconditions, postconditions, and assertions.\n\n##### Enforcement\n\n(Not enforceable) Finding the variety of ways postconditions can be asserted is not feasible. Warning about those that can be easily identified (`assert()`) has questionable value in the absence of a language facility.\n\n### <a name=\"ri-concepts\"></a>I.9: If an interface is a template, document its parameters using concepts\n\n##### Reason\n\nMake the interface precisely specified and compile-time checkable in the (not so distant) future.\n\n##### Example\n\nUse the C++20 style of requirements specification. For example:\n\n    template<typename Iter, typename Val>\n      requires input_iterator<Iter> && equality_comparable_with<iter_value_t<Iter>, Val>\n    Iter find(Iter first, Iter last, Val v)\n    {\n        // ...\n    }\n\n**See also**: [Generic programming](#ss-gp) and [concepts](#ss-concepts).\n\n##### Enforcement\n\nWarn if any non-variadic template parameter is not constrained by a concept (in its declaration or mentioned in a `requires` clause).\n\n### <a name=\"ri-except\"></a>I.10: Use exceptions to signal a failure to perform a required task\n\n##### Reason\n\nIt should not be possible to ignore an error because that could leave the system or a computation in an undefined (or unexpected) state.\nThis is a major source of errors.\n\n##### Example\n\n    int printf(const char* ...);    // bad: return negative number if output fails\n\n    template<class F, class ...Args>\n    // good: throw system_error if unable to start the new thread\n    explicit thread(F&& f, Args&&... args);\n\n##### Note\n\nWhat is an error?\n\nAn error means that the function cannot achieve its advertised purpose (including establishing postconditions).\nCalling code that ignores an error could lead to wrong results or undefined systems state.\nFor example, not being able to connect to a remote server is not by itself an error:\nthe server can refuse a connection for all kinds of reasons, so the natural thing is to return a result that the caller should always check.\nHowever, if failing to make a connection is considered an error, then a failure should throw an exception.\n\n##### Exception\n\nMany traditional interface functions (e.g., UNIX signal handlers) use error codes (e.g., `errno`) to report what are really status codes, rather than errors. You don't have a good alternative to using such, so calling these does not violate the rule.\n\n##### Alternative\n\nIf you can't use exceptions (e.g., because your code is full of old-style raw-pointer use or because there are hard-real-time constraints), consider using a style that returns a pair of values:\n\n    int val;\n    int error_code;\n    tie(val, error_code) = do_something();\n    if (error_code) {\n        // ... handle the error or exit ...\n    }\n    // ... use val ...\n\nThis style unfortunately leads to uninitialized variables.\nSince C++17 the \"structured bindings\" feature can be used to initialize variables directly from the return value:\n\n    auto [val, error_code] = do_something();\n    if (error_code) {\n        // ... handle the error or exit ...\n    }\n    // ... use val ...\n\n##### Note\n\nWe don't consider \"performance\" a valid reason not to use exceptions.\n\n* Often, explicit error checking and handling consume as much time and space as exception handling.\n* Often, cleaner code yields better performance with exceptions (simplifying the tracing of paths through the program and their optimization).\n* A good rule for performance critical code is to move checking outside the [critical](#rper-critical) part of the code.\n* In the longer term, more regular code gets better optimized.\n* Always carefully [measure](#rper-measure) before making performance claims.\n\n**See also**: [I.5](#ri-pre) and [I.7](#ri-post) for reporting precondition and postcondition violations.\n\n##### Enforcement\n\n* (Not enforceable) This is a philosophical guideline that is infeasible to check directly.\n* Look for `errno`.\n\n### <a name=\"ri-raw\"></a>I.11: Never transfer ownership by a raw pointer (`T*`) or reference (`T&`)\n\n##### Reason\n\nIf there is any doubt whether the caller or the callee owns an object, leaks or premature destruction will occur.\n\n##### Example\n\nConsider:\n\n    X* compute(args)    // don't\n    {\n        X* res = new X{};\n        // ...\n        return res;\n    }\n\nWho deletes the returned `X`? The problem would be harder to spot if `compute` returned a reference.\nConsider returning the result by value (use move semantics if the result is large):\n\n    vector<double> compute(args)  // good\n    {\n        vector<double> res(10000);\n        // ...\n        return res;\n    }\n\n**Alternative**: [Pass ownership](#rr-smartptrparam) using a \"smart pointer\", such as `unique_ptr` (for exclusive ownership) and `shared_ptr` (for shared ownership).\nHowever, that is less elegant and often less efficient than returning the object itself,\nso use smart pointers only if reference semantics are needed.\n\n**Alternative**: Sometimes older code can't be modified because of ABI compatibility requirements or lack of resources.\nIn that case, mark owning pointers using `owner` from the [guidelines support library](#gsl-guidelines-support-library):\n\n    owner<X*> compute(args)    // It is now clear that ownership is transferred\n    {\n        owner<X*> res = new X{};\n        // ...\n        return res;\n    }\n\nThis tells analysis tools that `res` is an owner.\nThat is, its value must be `delete`d or transferred to another owner, as is done here by the `return`.\n\n`owner` is used similarly in the implementation of resource handles.\n\n##### Note\n\nEvery object passed as a raw pointer (or iterator) is assumed to be owned by the\ncaller, so that its lifetime is handled by the caller. Viewed another way:\nownership transferring APIs are relatively rare compared to pointer-passing APIs,\nso the default is \"no ownership transfer.\"\n\n**See also**: [Argument passing](#rf-conventional), [use of smart pointer arguments](#rr-smartptrparam), and [value return](#rf-value-return).\n\n##### Enforcement\n\n* (Simple) Warn on `delete` of a raw pointer that is not an `owner<T>`. Suggest use of standard-library resource handle or use of `owner<T>`.\n* (Simple) Warn on failure to either `reset` or explicitly `delete` an `owner` pointer on every code path.\n* (Simple) Warn if the return value of `new` or a function call with an `owner` return value is assigned to a raw pointer or non-`owner` reference.\n\n### <a name=\"ri-nullptr\"></a>I.12: Declare a pointer that must not be null as `not_null`\n\n##### Reason\n\nTo help avoid dereferencing `nullptr` errors.\nTo improve performance by avoiding redundant checks for `nullptr`.\n\n##### Example\n\n    int length(const char* p);            // it is not clear whether length(nullptr) is valid\n\n    length(nullptr);                      // OK?\n\n    int length(not_null<const char*> p);  // better: we can assume that p cannot be nullptr\n\n    int length(const char* p);            // we must assume that p can be nullptr\n\nBy stating the intent in source, implementers and tools can provide better diagnostics, such as finding some classes of errors through static analysis, and perform optimizations, such as removing branches and null tests.\n\n##### Note\n\n`not_null` is defined in the [guidelines support library](#gsl-guidelines-support-library).\n\n##### Note\n\nThe assumption that the pointer to `char` pointed to a C-style string (a zero-terminated string of characters) was still implicit, and a potential source of confusion and errors. Use `czstring` in preference to `const char*`.\n\n    // we can assume that p cannot be nullptr\n    // we can assume that p points to a zero-terminated array of characters\n    int length(not_null<czstring> p);\n\nNote: `length()` is, of course, `std::strlen()` in disguise.\n\n##### Enforcement\n\n* (Simple) ((Foundation)) If a function checks a pointer parameter against `nullptr` before access, on all control-flow paths, then warn it should be declared `not_null`.\n* (Complex) If a function with pointer return value ensures it is not `nullptr` on all return paths, then warn the return type should be declared `not_null`.\n\n### <a name=\"ri-array\"></a>I.13: Do not pass an array as a single pointer\n\n##### Reason\n\n (pointer, size)-style interfaces are error-prone. Also, a plain pointer (to array) must rely on some convention to allow the callee to determine the size.\n\n##### Example\n\nConsider:\n\n    void copy_n(const T* p, T* q, int n); // copy from [p:p+n) to [q:q+n)\n\nWhat if there are fewer than `n` elements in the array pointed to by `q`? Then, we overwrite some probably unrelated memory.\nWhat if there are fewer than `n` elements in the array pointed to by `p`? Then, we read some probably unrelated memory.\nEither is undefined behavior and a potentially very nasty bug.\n\n##### Alternative\n\nConsider using explicit spans:\n\n    void copy(span<const T> r, span<T> r2); // copy r to r2\n\n##### Example, bad\n\nConsider:\n\n    void draw(Shape* p, int n);  // poor interface; poor code\n    Circle arr[10];\n    // ...\n    draw(arr, 10);\n\nPassing `10` as the `n` argument might be a mistake: the most common convention is to assume `[0:n)` but that is nowhere stated. Worse is that the call of `draw()` compiled at all: there was an implicit conversion from array to pointer (array decay) and then another implicit conversion from `Circle` to `Shape`. There is no way that `draw()` can safely iterate through that array: it has no way of knowing the size of the elements.\n\n**Alternative**: Use a support class that ensures that the number of elements is correct and prevents dangerous implicit conversions. For example:\n\n    void draw2(span<Circle>);\n    Circle arr[10];\n    // ...\n    draw2(span<Circle>(arr));  // deduce the number of elements\n    draw2(arr);    // deduce the element type and array size\n\n    void draw3(span<Shape>);\n    draw3(arr);    // error: cannot convert Circle[10] to span<Shape>\n\nThis `draw2()` passes the same amount of information to `draw()`, but makes the fact that it is supposed to be a range of `Circle`s explicit. See ???.\n\n##### Exception\n\nUse `zstring` and `czstring` to represent C-style, zero-terminated strings.\nBut when doing so, use `std::string_view` or `span<char>` from the [GSL](#gsl-guidelines-support-library) to prevent range errors.\n\n##### Enforcement\n\n* (Simple) ((Bounds)) Warn for any expression that would rely on implicit conversion of an array type to a pointer type. Allow exception for zstring/czstring pointer types.\n* (Simple) ((Bounds)) Warn for any arithmetic operation on an expression of pointer type that results in a value of pointer type. Allow exception for zstring/czstring pointer types.\n\n### <a name=\"ri-global-init\"></a>I.22: Avoid complex initialization of global objects\n\n##### Reason\n\nComplex initialization can lead to undefined order of execution.\n\n##### Example\n\n    // file1.c\n\n    extern const X x;\n\n    const Y y = f(x);   // read x; write y\n\n    // file2.c\n\n    extern const Y y;\n\n    const X x = g(y);   // read y; write x\n\nSince `x` and `y` are in different translation units the order of calls to `f()` and `g()` is undefined;\none will access an uninitialized `const`.\nThis shows that the order-of-initialization problem for global (namespace scope) objects is not limited to global *variables*.\n\n##### Note\n\nOrder of initialization problems become particularly difficult to handle in concurrent code.\nIt is usually best to avoid global (namespace scope) objects altogether.\n\n##### Enforcement\n\n* Flag initializers of globals that call non-`constexpr` functions\n* Flag initializers of globals that access `extern` objects\n\n### <a name=\"ri-nargs\"></a>I.23: Keep the number of function arguments low\n\n##### Reason\n\nHaving many arguments opens opportunities for confusion. Passing lots of arguments is often costly compared to alternatives.\n\n##### Discussion\n\nThe two most common reasons why functions have too many parameters are:\n\n1. *Missing an abstraction.*\n   There is an abstraction missing, so that a compound value is being\n   passed as individual elements instead of as a single object that enforces an invariant.\n   This not only expands the parameter list, but it leads to errors because the component values\n   are no longer protected by an enforced invariant.\n\n2. *Violating \"one function, one responsibility.\"*\n   The function is trying to do more than one job and should probably be refactored.\n\n##### Example\n\nThe standard-library `merge()` is at the limit of what we can comfortably handle:\n\n    template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>\n    OutputIterator merge(InputIterator1 first1, InputIterator1 last1,\n                         InputIterator2 first2, InputIterator2 last2,\n                         OutputIterator result, Compare comp);\n\nNote that this is because of problem 1 above -- missing abstraction. Instead of passing a range (abstraction), STL passed iterator pairs (unencapsulated component values).\n\nHere, we have four template arguments and six function arguments.\nTo simplify the most frequent and simplest uses, the comparison argument can be defaulted to `<`:\n\n    template<class InputIterator1, class InputIterator2, class OutputIterator>\n    OutputIterator merge(InputIterator1 first1, InputIterator1 last1,\n                         InputIterator2 first2, InputIterator2 last2,\n                         OutputIterator result);\n\nThis doesn't reduce the total complexity, but it reduces the surface complexity presented to many users.\nTo really reduce the number of arguments, we need to bundle the arguments into higher-level abstractions:\n\n    template<class InputRange1, class InputRange2, class OutputIterator>\n    OutputIterator merge(InputRange1 r1, InputRange2 r2, OutputIterator result);\n\nGrouping arguments into \"bundles\" is a general technique to reduce the number of arguments and to increase the opportunities for checking.\n\nAlternatively, we could use a standard library concept to define the notion of three types that must be usable for merging:\n\n    template<class In1, class In2, class Out>\n      requires mergeable<In1, In2, Out>\n    Out merge(In1 r1, In2 r2, Out result);\n\n##### Example\n\nThe safety Profiles recommend replacing\n\n    void f(int* some_ints, int some_ints_length);  // BAD: C style, unsafe\n\nwith\n\n    void f(gsl::span<int> some_ints);              // GOOD: safe, bounds-checked\n\nHere, using an abstraction has safety and robustness benefits, and naturally also reduces the number of parameters.\n\n##### Note\n\nHow many parameters are too many? Try to use fewer than four (4) parameters.\nThere are functions that are best expressed with four individual parameters, but not many.\n\n**Alternative**: Use better abstraction: Group arguments into meaningful objects and pass the objects (by value or by reference).\n\n**Alternative**: Use default arguments or overloads to allow the most common forms of calls to be done with fewer arguments.\n\n##### Enforcement\n\n* Warn when a function declares two iterators (including pointers) of the same type instead of a range or a view.\n* (Not enforceable) This is a philosophical guideline that is infeasible to check directly.\n\n### <a name=\"ri-unrelated\"></a>I.24: Avoid adjacent parameters that can be invoked by the same arguments in either order with different meaning\n\n##### Reason\n\nAdjacent arguments of the same type are easily swapped by mistake.\n\n##### Example, bad\n\nConsider:\n\n    void copy_n(T* p, T* q, int n);  // copy from [p:p + n) to [q:q + n)\n\nThis is a nasty variant of a K&R C-style interface. It is easy to reverse the \"to\" and \"from\" arguments.\n\nUse `const` for the \"from\" argument:\n\n    void copy_n(const T* p, T* q, int n);  // copy from [p:p + n) to [q:q + n)\n\n##### Exception\n\nIf the order of the parameters is not important, there is no problem:\n\n    int max(int a, int b);\n\n##### Alternative\n\nDon't pass arrays as pointers, pass an object representing a range (e.g., a `span`):\n\n    void copy_n(span<const T> p, span<T> q);  // copy from p to q\n\n##### Alternative\n\nDefine a `struct` as the parameter type and name the fields for those parameters accordingly:\n\n    struct SystemParams {\n        string config_file;\n        string output_path;\n        seconds timeout;\n    };\n    void initialize(SystemParams p);\n\nThis tends to make invocations of this clear to future readers, as the parameters\nare often filled in by name at the call site.\n\n##### Note\n\nOnly the interface's designer can adequately address the source of violations of this guideline.\n\n##### Enforcement strategy\n\n(Simple) Warn if two consecutive parameters share the same type.\n\nWe are still looking for a less-simple enforcement.\n\n### <a name=\"ri-abstract\"></a>I.25: Prefer empty abstract classes as interfaces to class hierarchies\n\n##### Reason\n\nAbstract classes that are empty (have no non-static member data) are more likely to be stable than base classes with state.\n\n##### Example, bad\n\nYou just knew that `Shape` would turn up somewhere :-)\n\n    class Shape {  // bad: interface class loaded with data\n    public:\n        Point center() const { return c; }\n        virtual void draw() const;\n        virtual void rotate(int);\n        // ...\n    private:\n        Point c;\n        vector<Point> outline;\n        Color col;\n    };\n\nThis will force every derived class to compute a center -- even if that's non-trivial and the center is never used. Similarly, not every `Shape` has a `Color`, and many `Shape`s are best represented without an outline defined as a sequence of `Point`s. Using an abstract class is better:\n\n    class Shape {    // better: Shape is a pure interface\n    public:\n        virtual Point center() const = 0;   // pure virtual functions\n        virtual void draw() const = 0;\n        virtual void rotate(int) = 0;\n        // ...\n        // ... no data members ...\n        // ...\n        virtual ~Shape() = default;\n    };\n\n##### Enforcement\n\n(Simple) Warn if a pointer/reference to a class `C` is assigned to a pointer/reference to a base of `C` and the base class contains data members.\n\n### <a name=\"ri-abi\"></a>I.26: If you want a cross-compiler ABI, use a C-style subset\n\n##### Reason\n\nDifferent compilers implement different binary layouts for classes, exception handling, function names, and other implementation details.\n\n##### Exception\n\nCommon ABIs are emerging on some platforms freeing you from the more draconian restrictions.\n\n##### Note\n\nIf you use a single compiler, you can use full C++ in interfaces. That might require recompilation after an upgrade to a new compiler version.\n\n##### Enforcement\n\n(Not enforceable) It is difficult to reliably identify where an interface forms part of an ABI.\n\n### <a name=\"ri-pimpl\"></a>I.27: For stable library ABI, consider the Pimpl idiom\n\n##### Reason\n\nBecause private data members participate in class layout and private member functions participate in overload resolution, changes to those\nimplementation details require recompilation of all users of a class that uses them. A non-polymorphic interface class holding a pointer to\nimplementation (Pimpl) can isolate the users of a class from changes in its implementation at the cost of an indirection.\n\n##### Example\n\ninterface (widget.h)\n\n    class widget {\n        class impl;\n        std::unique_ptr<impl> pimpl;\n    public:\n        void draw(); // public API that will be forwarded to the implementation\n        widget(int); // defined in the implementation file\n        ~widget();   // defined in the implementation file, where impl is a complete type\n        widget(widget&&) noexcept; // defined in the implementation file\n        widget(const widget&) = delete;\n        widget& operator=(widget&&) noexcept; // defined in the implementation file\n        widget& operator=(const widget&) = delete;\n    };\n\n\nimplementation (widget.cpp)\n\n    class widget::impl {\n        int n; // private data\n    public:\n        void draw(const widget& w) { /* ... */ }\n        impl(int n) : n(n) {}\n    };\n    void widget::draw() { pimpl->draw(*this); }\n    widget::widget(int n) : pimpl{std::make_unique<impl>(n)} {}\n    widget::widget(widget&&) noexcept = default;\n    widget::~widget() = default;\n    widget& widget::operator=(widget&&) noexcept = default;\n\n##### Notes\n\nSee [GOTW #100](https://herbsutter.com/gotw/_100/) and [cppreference](https://en.cppreference.com/w/cpp/language/pimpl) for the trade-offs and additional implementation details associated with this idiom.\n\n##### Enforcement\n\n(Not enforceable) It is difficult to reliably identify where an interface forms part of an ABI.\n\n### <a name=\"ri-encapsulate\"></a>I.30: Encapsulate rule violations\n\n##### Reason\n\nTo keep code simple and safe.\nSometimes, ugly, unsafe, or error-prone techniques are necessary for logical or performance reasons.\nIf so, keep them local, rather than \"infecting\" interfaces so that larger groups of programmers have to be aware of the\nsubtleties.\nImplementation complexity should, if at all possible, not leak through interfaces into user code.\n\n##### Example\n\nConsider a program that, depending on some form of input (e.g., arguments to `main`), should consume input\nfrom a file, from the command line, or from standard input.\nWe might write\n\n    bool owned;\n    owner<istream*> inp;\n    switch (source) {\n    case std_in:        owned = false; inp = &cin;                       break;\n    case command_line:  owned = true;  inp = new istringstream{argv[2]}; break;\n    case file:          owned = true;  inp = new ifstream{argv[2]};      break;\n    }\n    istream& in = *inp;\n\nThis violated the rule [against uninitialized variables](#res-always),\nthe rule against [ignoring ownership](#ri-raw),\nand the rule [against magic constants](#res-magic).\nIn particular, someone has to remember to somewhere write\n\n    if (owned) delete inp;\n\nWe could handle this particular example by using `unique_ptr` with a special deleter that does nothing for `cin`,\nbut that's complicated for novices (who can easily encounter this problem) and the example is an example of a more general\nproblem where a property that we would like to consider static (here, ownership) needs infrequently be addressed\nat run time.\nThe common, most frequent, and safest examples can be handled statically, so we don't want to add cost and complexity to those.\nBut we must also cope with the uncommon, less-safe, and necessarily more expensive cases.\nSuch examples are discussed in [[Str15]](https://www.stroustrup.com/resource-model.pdf).\n\nSo, we write a class\n\n    class Istream { [[gsl::suppress(\"lifetime\")]]\n    public:\n        enum Opt { from_line = 1 };\n        Istream() { }\n        Istream(czstring p) : owned{true}, inp{new ifstream{p}} {}            // read from file\n        Istream(czstring p, Opt) : owned{true}, inp{new istringstream{p}} {}  // read from command line\n        ~Istream() { if (owned) delete inp; }\n        operator istream&() { return *inp; }\n    private:\n        bool owned = false;\n        istream* inp = &cin;\n    };\n\nNow, the dynamic nature of `istream` ownership has been encapsulated.\nPresumably, a bit of checking for potential errors would be added in real code.\n\n##### Enforcement\n\n* Hard, it is hard to decide what rule-breaking code is essential\n* Flag rule suppression that enable rule-violations to cross interfaces\n\n# <a name=\"s-functions\"></a>F: Functions\n\nA function specifies an action or a computation that takes the system from one consistent state to the next. It is the fundamental building block of programs.\n\nIt should be possible to name a function meaningfully, to specify the requirements of its argument, and clearly state the relationship between the arguments and the result. An implementation is not a specification. Try to think about what a function does as well as about how it does it.\nFunctions are the most critical part in most interfaces, so see the interface rules.\n\nFunction rule summary:\n\nFunction definition rules:\n\n* [F.1: \"Package\" meaningful operations as carefully named functions](#rf-package)\n* [F.2: A function should perform a single logical operation](#rf-logical)\n* [F.3: Keep functions short and simple](#rf-single)\n* [F.4: If a function might have to be evaluated at compile time, declare it `constexpr`](#rf-constexpr)\n* [F.5: If a function is very small and time-critical, declare it inline](#rf-inline)\n* [F.6: If your function must not throw, declare it `noexcept`](#rf-noexcept)\n* [F.7: For general use, take `T*` or `T&` arguments rather than smart pointers](#rf-smart)\n* [F.8: Prefer pure functions](#rf-pure)\n* [F.9: Unused parameters should be unnamed](#rf-unused)\n* [F.10: If an operation can be reused, give it a name](#rf-name)\n* [F.11: Use an unnamed lambda if you need a simple function object in one place only](#rf-lambda)\n\nParameter passing expression rules:\n\n* [F.15: Prefer simple and conventional ways of passing information](#rf-conventional)\n* [F.16: For \"in\" parameters, pass cheaply-copied types by value and others by reference to `const`](#rf-in)\n* [F.17: For \"in-out\" parameters, pass by reference to non-`const`](#rf-inout)\n* [F.18: For \"will-move-from\" parameters, pass by `X&&` and `std::move` the parameter](#rf-consume)\n* [F.19: For \"forward\" parameters, pass by `TP&&` and only `std::forward` the parameter](#rf-forward)\n* [F.20: For \"out\" output values, prefer return values to output parameters](#rf-out)\n* [F.21: To return multiple \"out\" values, prefer returning a struct](#rf-out-multi)\n* [F.60: Prefer `T*` over `T&` when \"no argument\" is a valid option](#rf-ptr-ref)\n\nParameter passing semantic rules:\n\n* [F.22: Use `T*` or `owner<T*>` to designate a single object](#rf-ptr)\n* [F.23: Use a `not_null<T>` to indicate that \"null\" is not a valid value](#rf-nullptr)\n* [F.24: Use a `span<T>` or a `span_p<T>` to designate a half-open sequence](#rf-range)\n* [F.25: Use a `zstring` or a `not_null<zstring>` to designate a C-style string](#rf-zstring)\n* [F.26: Use a `unique_ptr<T>` to transfer ownership where a pointer is needed](#rf-unique_ptr)\n* [F.27: Use a `shared_ptr<T>` to share ownership](#rf-shared_ptr)\n\n<a name=\"rf-value-return\"></a>Value return semantic rules:\n\n* [F.42: Return a `T*` to indicate a position (only)](#rf-return-ptr)\n* [F.43: Never (directly or indirectly) return a pointer or a reference to a local object](#rf-dangle)\n* [F.44: Return a `T&` when copy is undesirable and \"returning no object\" isn't needed](#rf-return-ref)\n* [F.45: Don't return a `T&&`](#rf-return-ref-ref)\n* [F.46: `int` is the return type for `main()`](#rf-main)\n* [F.47: Return `T&` from assignment operators](#rf-assignment-op)\n* [F.48: Don't return `std::move(local)`](#rf-return-move-local)\n* [F.49: Don't return `const T`](#rf-return-const)\n\nOther function rules:\n\n* [F.50: Use a lambda when a function won't do (to capture local variables, or to write a local function)](#rf-capture-vs-overload)\n* [F.51: Where there is a choice, prefer default arguments over overloading](#rf-default-args)\n* [F.52: Prefer capturing by reference in lambdas that will be used locally, including passed to algorithms](#rf-reference-capture)\n* [F.53: Avoid capturing by reference in lambdas that will be used non-locally, including returned, stored on the heap, or passed to another thread](#rf-value-capture)\n* [F.54: When writing a lambda that captures `this` or any class data member, don't use `[=]` default capture](#rf-this-capture)\n* [F.55: Don't use `va_arg` arguments](#f-varargs)\n* [F.56: Avoid unnecessary condition nesting](#f-nesting)\n\nFunctions have strong similarities to lambdas and function objects.\n\n**See also**: [C.lambdas: Function objects and lambdas](#ss-lambdas)\n\n## <a name=\"ss-fct-def\"></a>F.def: Function definitions\n\nA function definition is a function declaration that also specifies the function's implementation, the function body.\n\n### <a name=\"rf-package\"></a>F.1: \"Package\" meaningful operations as carefully named functions\n\n##### Reason\n\nFactoring out common code makes code more readable, more likely to be reused, and limit errors from complex code.\nIf something is a well-specified action, separate it out from its surrounding code and give it a name.\n\n##### Example, don't\n\n    void read_and_print(istream& is)    // read and print an int\n    {\n        int x;\n        if (is >> x)\n            cout << \"the int is \" << x << '\\n';\n        else\n            cerr << \"no int on input\\n\";\n    }\n\nAlmost everything is wrong with `read_and_print`.\nIt reads, it writes (to a fixed `ostream`), it writes error messages (to a fixed `ostream`), it handles only `int`s.\nThere is nothing to reuse, logically separate operations are intermingled and local variables are in scope after the end of their logical use.\nFor a tiny example, this looks OK, but if the input operation, the output operation, and the error handling had been more complicated the tangled\nmess could become hard to understand.\n\n##### Note\n\nIf you write a non-trivial lambda that potentially can be used in more than one place, give it a name by assigning it to a (usually non-local) variable.\n\n##### Example\n\n    sort(a, b, [](T x, T y) { return x.rank() < y.rank() && x.value() < y.value(); });\n\nNaming that lambda breaks up the expression into its logical parts and provides a strong hint to the meaning of the lambda.\n\n    auto lessT = [](T x, T y) { return x.rank() < y.rank() && x.value() < y.value(); };\n\n    sort(a, b, lessT);\n\nThe shortest code is not always the best for performance or maintainability.\n\n##### Exception\n\nLoop bodies, including lambdas used as loop bodies, rarely need to be named.\nHowever, large loop bodies (e.g., dozens of lines or dozens of pages) can be a problem.\nThe rule [Keep functions short and simple](#rf-single) implies \"Keep loop bodies short.\"\nSimilarly, lambdas used as callback arguments are sometimes non-trivial, yet unlikely to be reusable.\n\n##### Enforcement\n\n* See [Keep functions short and simple](#rf-single)\n* Flag identical and very similar lambdas used in different places.\n\n### <a name=\"rf-logical\"></a>F.2: A function should perform a single logical operation\n\n##### Reason\n\nA function that performs a single operation is simpler to understand, test, and reuse.\n\n##### Example\n\nConsider:\n\n    void read_and_print()    // bad\n    {\n        int x;\n        cin >> x;\n        // check for errors\n        cout << x << \"\\n\";\n    }\n\nThis is a monolith that is tied to a specific input and will never find another (different) use. Instead, break functions up into suitable logical parts and parameterize:\n\n    int read(istream& is)    // better\n    {\n        int x;\n        is >> x;\n        // check for errors\n        return x;\n    }\n\n    void print(ostream& os, int x)\n    {\n        os << x << \"\\n\";\n    }\n\nThese can now be combined where needed:\n\n    void read_and_print()\n    {\n        auto x = read(cin);\n        print(cout, x);\n    }\n\nIf there was a need, we could further templatize `read()` and `print()` on the data type, the I/O mechanism, the response to errors, etc. Example:\n\n    auto read = [](auto& input, auto& value)    // better\n    {\n        input >> value;\n        // check for errors\n    };\n\n    void print(auto& output, const auto& value)\n    {\n        output << value << \"\\n\";\n    }\n\n##### Enforcement\n\n* Consider functions with more than one \"out\" parameter suspicious. Use return values instead, including `tuple` for multiple return values.\n* Consider \"large\" functions that don't fit on one editor screen suspicious. Consider factoring such a function into smaller well-named suboperations.\n* Consider functions with 7 or more parameters suspicious.\n\n### <a name=\"rf-single\"></a>F.3: Keep functions short and simple\n\n##### Reason\n\nLarge functions are hard to read, more likely to contain complex code, and more likely to have variables in larger than minimal scopes.\nFunctions with complex control structures are more likely to be long and more likely to hide logical errors\n\n##### Example\n\nConsider:\n\n    double simple_func(double val, int flag1, int flag2)\n        // simple_func: takes a value and calculates the expected ASIC output,\n        // given the two mode flags.\n    {\n        double intermediate;\n        if (flag1 > 0) {\n            intermediate = func1(val);\n            if (flag2 % 2)\n                 intermediate = sqrt(intermediate);\n        }\n        else if (flag1 == -1) {\n            intermediate = func1(-val);\n            if (flag2 % 2)\n                 intermediate = sqrt(-intermediate);\n            flag1 = -flag1;\n        }\n        if (abs(flag2) > 10) {\n            intermediate = func2(intermediate);\n        }\n        switch (flag2 / 10) {\n        case 1: if (flag1 == -1) return finalize(intermediate, 1.171);\n                break;\n        case 2: return finalize(intermediate, 13.1);\n        default: break;\n        }\n        return finalize(intermediate, 0.);\n    }\n\nThis is too complex.\nHow would you know if all possible alternatives have been correctly handled?\nYes, it breaks other rules also.\n\nWe can refactor:\n\n    double func1_muon(double val, int flag)\n    {\n        // ???\n    }\n\n    double func1_tau(double val, int flag1, int flag2)\n    {\n        // ???\n    }\n\n    double simple_func(double val, int flag1, int flag2)\n        // simple_func: takes a value and calculates the expected ASIC output,\n        // given the two mode flags.\n    {\n        if (flag1 > 0)\n            return func1_muon(val, flag2);\n        if (flag1 == -1)\n            // handled by func1_tau: flag1 = -flag1;\n            return func1_tau(-val, flag1, flag2);\n        return 0.;\n    }\n\n##### Note\n\n\"It doesn't fit on a screen\" is often a good practical definition of \"far too large.\"\nOne-to-five-line functions should be considered normal.\n\n##### Note\n\nBreak large functions up into smaller cohesive and named functions.\nSmall simple functions are easily inlined where the cost of a function call is significant.\n\n##### Enforcement\n\n* Flag functions that do not \"fit on a screen.\"\n  How big is a screen? Try 60 lines by 140 characters; that's roughly the maximum that's comfortable for a book page.\n* Flag functions that are too complex. How complex is too complex?\n  You could use cyclomatic complexity. Try \"more than 10 logical paths through.\" Count a simple switch as one path.\n\n### <a name=\"rf-constexpr\"></a>F.4: If a function might have to be evaluated at compile time, declare it `constexpr`\n\n##### Reason\n\n `constexpr` is needed to tell the compiler to allow compile-time evaluation.\n\n##### Example\n\nThe (in)famous factorial:\n\n    constexpr int fac(int n)\n    {\n        constexpr int max_exp = 17;      // constexpr enables max_exp to be used in Expects\n        Expects(0 <= n && n < max_exp);  // prevent silliness and overflow\n        int x = 1;\n        for (int i = 2; i <= n; ++i) x *= i;\n        return x;\n    }\n\nThis is C++14.\nFor C++11, use a recursive formulation of `fac()`.\n\n##### Note\n\n`constexpr` does not guarantee compile-time evaluation;\nit just guarantees that the function can be evaluated at compile time for constant expression arguments if the programmer requires it or the compiler decides to do so to optimize.\n\n    constexpr int min(int x, int y) { return x < y ? x : y; }\n\n    void test(int v)\n    {\n        int m1 = min(-1, 2);            // probably compile-time evaluation\n        constexpr int m2 = min(-1, 2);  // compile-time evaluation\n        int m3 = min(-1, v);            // run-time evaluation\n        constexpr int m4 = min(-1, v);  // error: cannot evaluate at compile time\n    }\n\n##### Note\n\nDon't try to make all functions `constexpr`.\nMost computation is best done at run time.\n\n##### Note\n\nAny API that might eventually depend on high-level run-time configuration or\nbusiness logic should not be made `constexpr`. Such customization can not be\nevaluated by the compiler, and any `constexpr` functions that depended upon\nthat API would have to be refactored or drop `constexpr`.\n\n##### Enforcement\n\nImpossible and unnecessary.\nThe compiler gives an error if a non-`constexpr` function is called where a constant is required.\n\n### <a name=\"rf-inline\"></a>F.5: If a function is very small and time-critical, declare it `inline`\n\n##### Reason\n\nSome optimizers are good at inlining without hints from the programmer, but don't rely on it.\nMeasure! Over the last 40 years or so, we have been promised compilers that can inline better than humans without hints from humans.\nWe are still waiting.\nSpecifying inline (explicitly, or implicitly when writing member functions inside a class definition) encourages the compiler to do a better job.\n\n##### Example\n\n    inline string cat(const string& s, const string& s2) { return s + s2; }\n\n##### Exception\n\nDo not put an `inline` function in what is meant to be a stable interface unless you are certain that it will not change.\nAn inline function is part of the ABI.\n\n##### Note\n\n`constexpr` implies `inline`.\n\n##### Note\n\nMember functions defined in-class are `inline` by default.\n\n##### Exception\n\nFunction templates (including member functions of class templates `A<T>::function()` and member function templates `A::function<T>()`) are normally defined in headers and therefore inline.\n\n##### Note\n\nConsider making functions out of line if they are more than three statements and can be declared out of line (such as class member functions).\n\n### <a name=\"rf-noexcept\"></a>F.6: If your function must not throw, declare it `noexcept`\n\n##### Reason\n\nIf an exception is not supposed to be thrown, the program cannot be assumed to cope with the error and should be terminated as soon as possible. Declaring a function `noexcept` helps optimizers by reducing the number of alternative execution paths. It also speeds up the exit after failure.\n\n##### Example\n\nPut `noexcept` on every function written completely in C or in any other language without exceptions.\nThe C++ Standard Library does that implicitly for all functions in the C Standard Library.\n\n##### Note\n\n`constexpr` functions can throw when evaluated at run time, so you might need conditional `noexcept` for some of those.\n\n##### Example\n\nYou can use `noexcept` even on functions that can throw:\n\n    vector<string> collect(istream& is) noexcept\n    {\n        vector<string> res;\n        for (string s; is >> s;)\n            res.push_back(s);\n        return res;\n    }\n\nIf `collect()` runs out of memory, the program crashes.\nUnless the program is crafted to survive memory exhaustion, that might be just the right thing to do;\n`terminate()` might generate suitable error log information (but after memory runs out it is hard to do anything clever).\n\n##### Note\n\nYou must be aware of the execution environment that your code is running when\ndeciding whether to tag a function `noexcept`, especially because of the issue\nof throwing and allocation.  Code that is intended to be perfectly general (like\nthe standard library and other utility code of that sort) needs to support\nenvironments where a `bad_alloc` exception could be handled meaningfully.\nHowever, most programs and execution environments cannot meaningfully\nhandle a failure to allocate, and aborting the program is the cleanest and\nsimplest response to an allocation failure in those cases.  If you know that\nyour application code cannot respond to an allocation failure, it could be\nappropriate to add `noexcept` even on functions that allocate.\n\nPut another way: In most programs, most functions can throw (e.g., because they\nuse `new`, call functions that do, or use library functions that report failure\nby throwing), so don't just sprinkle `noexcept` all over the place without\nconsidering whether the possible exceptions can be handled.\n\n`noexcept` is most useful (and most clearly correct) for frequently used,\nlow-level functions.\n\n##### Note\n\nDestructors, `swap` functions, move operations, and default constructors should never throw.\nSee also [C.44](#rc-default00).\n\n##### Note\n\nCare must be taken on base virtual functions and functions part of a public interface because declaring a function `noexcept` is establishing a guarantee that all current and future implementations must abide by.  For virtual function, all overriders must also be `noexcept` and removing `noexcept` from a function could break calling functions. \n\n##### Enforcement\n\n* (hard) Flag low-level functions that are not `noexcept`, yet cannot throw.\n* Flag throwing `swap`, `move`, destructors, and default constructors.\n\n### <a name=\"rf-smart\"></a>F.7: For general use, take `T*` or `T&` arguments rather than smart pointers\n\n##### Reason\n\nPassing a smart pointer transfers or shares ownership and should only be used when ownership semantics are intended.\nA function that does not manipulate lifetime should take raw pointers or references instead.\n\nPassing by smart pointer restricts the use of a function to callers that use smart pointers.\nA function that needs a `widget` should be able to accept any `widget` object, not just ones whose lifetimes are managed by a particular kind of smart pointer.\n\nPassing a shared smart pointer (e.g., `std::shared_ptr`) implies a run-time cost.\n\n##### Example\n\n    // accepts any int*\n    void f(int*);\n\n    // can only accept ints for which you want to transfer ownership\n    void g(unique_ptr<int>);\n\n    // can only accept ints for which you are willing to share ownership\n    void g(shared_ptr<int>);\n\n    // doesn't change ownership, but requires a particular ownership of the caller\n    void h(const unique_ptr<int>&);\n\n    // accepts any int\n    void h(int&);\n\n##### Example, bad\n\n    // callee\n    void f(shared_ptr<widget>& w)\n    {\n        // ...\n        use(*w); // only use of w -- the lifetime is not used at all\n        // ...\n    };\n\n    // caller\n    shared_ptr<widget> my_widget = /* ... */;\n    f(my_widget);\n\n    widget stack_widget;\n    f(stack_widget); // error\n\n##### Example, good\n\n    // callee\n    void f(widget& w)\n    {\n        // ...\n        use(w);\n        // ...\n    };\n\n    // caller\n    shared_ptr<widget> my_widget = /* ... */;\n    f(*my_widget);\n\n    widget stack_widget;\n    f(stack_widget); // ok -- now this works\n\n##### Note\n\nWe can catch many common cases of dangling pointers statically (see [lifetime safety profile](#ss-lifetime)). Function arguments naturally live for the lifetime of the function call, and so have fewer lifetime problems.\n\n##### Enforcement\n\n* (Simple) Warn if a function takes a parameter of a smart pointer type (that overloads `operator->` or `operator*`) that is copyable but the function only calls any of: `operator*`, `operator->` or `get()`.\n  Suggest using a `T*` or `T&` instead.\n* Flag a parameter of a smart pointer type (a type that overloads `operator->` or `operator*`) that is copyable/movable but never copied/moved from in the function body, and that is never modified, and that is not passed along to another function that could do so. That means the ownership semantics are not used.\n  Suggest using a `T*` or `T&` instead.\n\n**See also**:\n\n* [Prefer `T*` over `T&` when \"no argument\" is a valid option](#rf-ptr-ref)\n* [Smart pointer rule summary](#rr-summary-smartptrs)\n\n### <a name=\"rf-pure\"></a>F.8: Prefer pure functions\n\n##### Reason\n\nPure functions are easier to reason about, sometimes easier to optimize (and even parallelize), and sometimes can be memoized.\n\n##### Example\n\n    template<class T>\n    auto square(T t) { return t * t; }\n\n##### Enforcement\n\nNot possible.\n\n### <a name=\"rf-unused\"></a>F.9: Unused parameters should be unnamed\n\n##### Reason\n\nReadability.\nSuppression of unused parameter warnings.\n\n##### Example\n\n    widget* find(const set<widget>& s, const widget& w, Hint);   // once upon a time, a hint was used\n\n##### Note\n\nAllowing parameters to be unnamed was introduced in the early 1980s to address this problem.\n\nIf parameters are conditionally unused, declare them with the `[[maybe_unused]]` attribute.\nFor example:\n\n    template <typename Value>\n    Value* find(const set<Value>& s, const Value& v, [[maybe_unused]] Hint h)\n    {\n        if constexpr (sizeof(Value) > CacheSize)\n        {\n            // a hint is used only if Value is of a certain size\n        }\n    }\n\n##### Enforcement\n\nFlag named unused parameters.\n\n### <a name=\"rf-name\"></a>F.10: If an operation can be reused, give it a name\n\n##### Reason\n\nDocumentation, readability, opportunity for reuse.\n\n##### Example\n\n    struct Rec {\n        string name;\n        string addr;\n        int id;         // unique identifier\n    };\n\n    bool same(const Rec& a, const Rec& b)\n    {\n        return a.id == b.id;\n    }\n\n    vector<Rec*> find_id(const string& name);    // find all records for \"name\"\n\n    auto x = find_if(vr.begin(), vr.end(),\n        [&](Rec& r) {\n            if (r.name.size() != n.size()) return false; // name to compare to is in n\n            for (int i = 0; i < r.name.size(); ++i)\n                if (tolower(r.name[i]) != tolower(n[i])) return false;\n            return true;\n        }\n    );\n\nThere is a useful function lurking here (case insensitive string comparison), as there often is when lambda arguments get large.\n\n    bool compare_insensitive(const string& a, const string& b)\n    {\n        if (a.size() != b.size()) return false;\n        for (int i = 0; i < a.size(); ++i) if (tolower(a[i]) != tolower(b[i])) return false;\n        return true;\n    }\n\n    auto x = find_if(vr.begin(), vr.end(),\n        [&](Rec& r) { return compare_insensitive(r.name, n); }\n    );\n\nOr maybe (if you prefer to avoid the implicit name binding to n):\n\n    auto cmp_to_n = [&n](const string& a) { return compare_insensitive(a, n); };\n\n    auto x = find_if(vr.begin(), vr.end(),\n        [](const Rec& r) { return cmp_to_n(r.name); }\n    );\n\n##### Note\n\nwhether functions, lambdas, or operators.\n\n##### Exception\n\n* Lambdas logically used only locally, such as an argument to `for_each` and similar control flow algorithms.\n* Lambdas as [initializers](#???)\n\n##### Enforcement\n\n* (hard) flag similar lambdas\n* ???\n\n### <a name=\"rf-lambda\"></a>F.11: Use an unnamed lambda if you need a simple function object in one place only\n\n##### Reason\n\nThat makes the code concise and gives better locality than alternatives.\n\n##### Example\n\n    auto earlyUsersEnd = std::remove_if(users.begin(), users.end(),\n                                        [](const User &a) { return a.id > 100; });\n\n\n##### Exception\n\nNaming a lambda can be useful for clarity even if it is used only once.\n\n##### Enforcement\n\n* Look for identical and near identical lambdas (to be replaced with named functions or named lambdas).\n\n## <a name=\"ss-call\"></a>F.call: Parameter passing\n\nThere are a variety of ways to pass parameters to a function and to return values.\n\n### <a name=\"rf-conventional\"></a>F.15: Prefer simple and conventional ways of passing information\n\n##### Reason\n\nUsing \"unusual and clever\" techniques causes surprises, slows understanding by other programmers, and encourages bugs.\nIf you really feel the need for an optimization beyond the common techniques, measure to ensure that it really is an improvement, and document/comment because the improvement might not be portable.\n\nThe following tables summarize the advice in the following Guidelines, F.16-21.\n\nNormal parameter passing:\n\n![Normal parameter passing table](./param-passing-normal.png \"Normal parameter passing\")\n\nAdvanced parameter passing:\n\n![Advanced parameter passing table](./param-passing-advanced.png \"Advanced parameter passing\")\n\nUse the advanced techniques only after demonstrating need, and document that need in a comment.\n\nFor passing sequences of characters see [String](#ss-string).\n\n##### Exception\n\nTo express shared ownership using `shared_ptr` types, rather than following guidelines F.16-21,\nfollow [R.34](#rr-sharedptrparam-owner), [R.35](#rr-sharedptrparam), and [R.36](#rr-sharedptrparam-const).\n\n### <a name=\"rf-in\"></a>F.16: For \"in\" parameters, pass cheaply-copied types by value and others by reference to `const`\n\n##### Reason\n\nBoth let the caller know that a function will not modify the argument, and both allow initialization by rvalues.\n\nWhat is \"cheap to copy\" depends on the machine architecture, but two or three words (doubles, pointers, references) are usually best passed by value.\nWhen copying is cheap, nothing beats the simplicity and safety of copying, and for small objects (up to two or three words) it is also faster than passing by reference because it does not require an extra indirection to access from the function.\n\n##### Example\n\n    void f1(const string& s);  // OK: pass by reference to const; always cheap\n\n    void f2(string s);         // bad: potentially expensive\n\n    void f3(int x);            // OK: Unbeatable\n\n    void f4(const int& x);     // bad: overhead on access in f4()\n\nFor advanced uses (only), where you really need to optimize for rvalues passed to \"input-only\" parameters:\n\n* If the function is going to unconditionally move from the argument, take it by `&&`. See [F.18](#rf-consume).\n* If the function is going to keep a locally modifiable copy of the argument only for its own local use, taking it by value is fine.\n* If the function is going to keep a copy of the argument to pass to another destination (to another function, or store in a non-local location), in addition to passing by `const&` (for lvalues),\n  add an overload that passes the parameter by `&&` (for rvalues) and in the body `std::move`s it to its destination. Essentially this overloads a \"will-move-from\"; see [F.18](#rf-consume).\n* In special cases, such as multiple \"input + copy\" parameters, consider using perfect forwarding. See [F.19](#rf-forward).\n\n##### Example\n\n    int multiply(int, int); // just input ints, pass by value\n\n    // suffix is input-only but not as cheap as an int, pass by const&\n    string& concatenate(string&, const string& suffix);\n\n    void sink(unique_ptr<widget>);  // input only, and moves ownership of the widget\n\nAvoid \"esoteric techniques\" such as passing arguments as `T&&` \"for efficiency\".\nMost rumors about performance advantages from passing by `&&` are false or brittle (but see [F.18](#rf-consume) and [F.19](#rf-forward)).\n\n##### Notes\n\nA reference can be assumed to refer to a valid object (language rule).\nThere is no (legitimate) \"null reference.\"\nIf you need the notion of an optional value, use a pointer, `std::optional`, or a special value used to denote \"no value.\"\n\n##### Enforcement\n\n* (Simple) ((Foundation)) Warn when a parameter being passed by value has a size greater than `2 * sizeof(void*)`.\n  Suggest using a reference to `const` instead.\n* (Simple) ((Foundation)) Warn when a parameter passed by reference to `const` has a size less or equal than `2 * sizeof(void*)`. Suggest passing by value instead.\n* (Simple) ((Foundation)) Warn when a parameter passed by reference to `const` is `move`d.\n\n##### Exception\n\nTo express shared ownership using `shared_ptr` types, follow [R.34](#rr-sharedptrparam-owner) or [R.36](#rr-sharedptrparam-const),\ndepending on whether or not the function unconditionally takes a reference to the argument.\n\n### <a name=\"rf-inout\"></a>F.17: For \"in-out\" parameters, pass by reference to non-`const`\n\n##### Reason\n\nThis makes it clear to callers that the object is assumed to be modified.\n\n##### Example\n\n    void update(Record& r);  // assume that update writes to r\n\n##### Note\n\nSome user-defined and standard library types, such as `span<T>` or the iterators\nare [cheap to copy](#rf-in) and may be passed by value, while doing so has\nmutable (in-out) reference semantics:\n\n    void increment_all(span<int> a)\n    {\n      for (auto&& e : a)\n        ++e;\n    }\n\n##### Note\n\nA `T&` argument can pass information into a function as well as out of it.\nThus `T&` could be an in-out-parameter. That can in itself be a problem and a source of errors:\n\n    void f(string& s)\n    {\n        s = \"New York\";  // non-obvious error\n    }\n\n    void g()\n    {\n        string buffer = \".................................\";\n        f(buffer);\n        // ...\n    }\n\nHere, the writer of `g()` is supplying a buffer for `f()` to fill, but `f()` simply replaces it (at a somewhat higher cost than a simple copy of the characters).\nA bad logic error can happen if the writer of `g()` incorrectly assumes the size of the `buffer`.\n\n##### Enforcement\n\n* (Moderate) ((Foundation)) Warn about functions regarding reference to non-`const` parameters that do *not* write to them.\n* (Simple) ((Foundation)) Warn when a non-`const` parameter being passed by reference is `move`d.\n\n### <a name=\"rf-consume\"></a>F.18: For \"will-move-from\" parameters, pass by `X&&` and `std::move` the parameter\n\n##### Reason\n\nIt's efficient and eliminates bugs at the call site: `X&&` binds to rvalues, which requires an explicit `std::move` at the call site if passing an lvalue.\n\n##### Example\n\n    void sink(vector<int>&& v)  // sink takes ownership of whatever the argument owned\n    {\n        // usually there might be const accesses of v here\n        store_somewhere(std::move(v));\n        // usually no more use of v here; it is moved-from\n    }\n\nNote that the `std::move(v)` makes it possible for `store_somewhere()` to leave `v` in a moved-from state.\n[That could be dangerous](#rc-move-semantic).\n\n\n##### Exception\n\nUnique owner types that are move-only and cheap-to-move, such as `unique_ptr`, can also be passed by value which is simpler to write and achieves the same effect. Passing by value does generate one extra (cheap) move operation, but prefer simplicity and clarity first.\n\nFor example:\n\n    template<class T>\n    void sink(std::unique_ptr<T> p)\n    {\n        // use p ... possibly std::move(p) onward somewhere else\n    }   // p gets destroyed\n\n##### Exception\n\nIf the \"will-move-from\" parameter is a `shared_ptr` follow [R.34](#rr-sharedptrparam-owner) and pass the `shared_ptr` by value.\n\n##### Enforcement\n\n* Flag all `X&&` parameters (where `X` is not a template type parameter name) where the function body uses them without `std::move`.\n* Flag access to moved-from objects.\n* Don't conditionally move from objects\n\n### <a name=\"rf-forward\"></a>F.19: For \"forward\" parameters, pass by `TP&&` and only `std::forward` the parameter\n\n##### Reason\n\nIf the object is to be passed onward to other code and not directly used by this function, we want to make this function agnostic to the argument `const`-ness and rvalue-ness.\n\nIn that case, and only that case, make the parameter `TP&&` where `TP` is a template type parameter -- it both *ignores* and *preserves* `const`-ness and rvalue-ness. Therefore any code that uses a `TP&&` is implicitly declaring that it itself doesn't care about the variable's `const`-ness and rvalue-ness (because it is ignored), but that intends to pass the value onward to other code that does care about `const`-ness and rvalue-ness (because it is preserved). When used as a parameter `TP&&` is safe because any temporary objects passed from the caller will live for the duration of the function call. A parameter of type `TP&&` should essentially always be passed onward via `std::forward` in the body of the function.\n\n##### Example\n\nUsually you forward the entire parameter (or parameter pack, using `...`) exactly once on every static control flow path:\n\n    template<class F, class... Args>\n    inline decltype(auto) invoke(F&& f, Args&&... args)\n    {\n        return forward<F>(f)(forward<Args>(args)...);\n    }\n\n##### Example\n\nSometimes you may forward a composite parameter piecewise, each subobject once on every static control flow path:\n\n    template<class PairLike>\n    inline auto test(PairLike&& pairlike)\n    {\n        // ...\n        f1(some, args, and, forward<PairLike>(pairlike).first);           // forward .first\n        f2(and, forward<PairLike>(pairlike).second, in, another, call);   // forward .second\n    }\n\n##### Enforcement\n\n* Flag a function that takes a `TP&&` parameter (where `TP` is a template type parameter name) and does anything with it other than `std::forward`ing it exactly once on every static path, or `std::forward`ing it more than once but qualified with a different data member exactly once on every static path.\n\n### <a name=\"rf-out\"></a>F.20: For \"out\" output values, prefer return values to output parameters\n\n##### Reason\n\nA return value is self-documenting, whereas an `&` could be either in-out or out-only and is liable to be misused.\n\nThis includes large objects like standard containers that use implicit move operations for performance and to avoid explicit memory management.\n\nIf you have multiple values to return, [use a tuple](#rf-out-multi) or similar multi-member type.\n\n##### Example\n\n    // OK: return pointers to elements with the value x\n    vector<const int*> find_all(const vector<int>&, int x);\n\n    // Bad: place pointers to elements with value x in-out\n    void find_all(const vector<int>&, vector<const int*>& out, int x);\n\n##### Note\n\nA `struct` of many (individually cheap-to-move) elements might be in aggregate expensive to move.\n\n##### Exceptions\n\n* For non-concrete types, such as types in an inheritance hierarchy, return the object by `unique_ptr` or `shared_ptr`.\n* If a type is expensive to move (e.g., `array<BigTrivial>`), consider allocating it on the free store and return a handle (e.g., `unique_ptr`), or passing it in a reference to non-`const` target object to fill (to be used as an out-parameter).\n* To reuse an object that carries capacity (e.g., `std::string`, `std::vector`) across multiple calls to the function in an inner loop: [treat it as an in/out parameter and pass by reference](#rf-out-multi).\n\n##### Example\n\nAssuming that `Matrix` has move operations (possibly by keeping its elements in a `std::vector`):\n\n    Matrix operator+(const Matrix& a, const Matrix& b)\n    {\n        Matrix res;\n        // ... fill res with the sum ...\n        return res;\n    }\n\n    Matrix x = m1 + m2;  // move constructor\n\n    y = m3 + m3;         // move assignment\n\n\n##### Note\n\nThe return value optimization doesn't handle the assignment case, but the move assignment does.\n\n##### Example\n\n    struct Package {      // exceptional case: expensive-to-move object\n        char header[16];\n        char load[2024 - 16];\n    };\n\n    Package fill();       // Bad: large return value\n    void fill(Package&);  // OK\n\n    int val();            // OK\n    void val(int&);       // Bad: Is val reading its argument\n\n##### Enforcement\n\n* Flag reference to non-`const` parameters that are not read before being written to and are a type that could be cheaply returned; they should be \"out\" return values.\n\n### <a name=\"rf-out-multi\"></a>F.21: To return multiple \"out\" values, prefer returning a struct\n\n##### Reason\n\nA return value is self-documenting as an \"output-only\" value.\nNote that C++ does have multiple return values, by convention of using tuple-like types (`struct`, `array`, `tuple`, etc.),\npossibly with the extra convenience of structured bindings (C++17) at the call site.\nPrefer using a named `struct` if possible.\nOtherwise, a `tuple` is useful in variadic templates.\n\n##### Example\n\n    // BAD: output-only parameter documented in a comment\n    int f(const string& input, /*output only*/ string& output_data)\n    {\n        // ...\n        output_data = something();\n        return status;\n    }\n\n    // GOOD: self-documenting\n    struct f_result { int status; string data; };\n\n    f_result f(const string& input)\n    {\n        // ...\n        return {status, something()};\n    }\n\nC++98's standard library used this style in places, by returning `pair` in some functions.\nFor example, given a `set<string> my_set`, consider:\n\n    // C++98\n    pair<set::iterator, bool> result = my_set.insert(\"Hello\");\n    if (result.second)\n        do_something_with(result.first);    // workaround\n\nWith C++17 we are able to use \"structured bindings\" to give each member a name:\n\n    if (auto [ iter, success ] = my_set.insert(\"Hello\"); success)\n        do_something_with(iter);\n\nA `struct` with meaningful names is more common in modern C++.\nSee for example `ranges::min_max_result`, `from_chars_result`, and others.\n\n##### Exception\n\nSometimes, we need to pass an object to a function to manipulate its state.\nIn such cases, passing the object by reference [`T&`](#rf-inout) is usually the right technique.\nExplicitly passing an in-out parameter back out again as a return value is often not necessary.\nFor example:\n\n    istream& operator>>(istream& in, string& s);    // much like std::operator>>()\n\n    for (string s; in >> s; ) {\n        // do something with line\n    }\n\nHere, both `s` and `in` are used as in-out parameters.\nWe pass `in` by (non-`const`) reference to be able to manipulate its state.\nWe pass `s` to avoid repeated allocations.\nBy reusing `s` (passed by reference), we allocate new memory only when we need to expand `s`'s capacity.\nThis technique is sometimes called the \"caller-allocated out\" pattern and is particularly useful for types,\nsuch as `string` and `vector`, that need to do free store allocations.\n\nTo compare, if we passed out all values as return values, we would write something like this:\n\n    struct get_string_result { istream& in; string s; };\n\n    get_string_result get_string(istream& in)  // not recommended\n    {\n        string s;\n        in >> s;\n        return { in, move(s) };\n    }\n\n    for (auto [in, s] = get_string(cin); in; s = get_string(in).s) {\n        // do something with string\n    }\n\nWe consider that significantly less elegant with significantly less performance.\n\nFor a truly strict reading of this rule (F.21), the exception isn't really an exception because it relies on in-out parameters,\nrather than the plain out parameters mentioned in the rule.\nHowever, we prefer to be explicit, rather than subtle.\n\n##### Note\n\nIn most cases, it is useful to return a specific, user-defined type.\nFor example:\n\n    struct Distance {\n        int value;\n        int unit = 1;   // 1 means meters\n    };\n\n    Distance d1 = measure(obj1);        // access d1.value and d1.unit\n    auto d2 = measure(obj2);            // access d2.value and d2.unit\n    auto [value, unit] = measure(obj3); // access value and unit; somewhat redundant\n                                        // to people who know measure()\n    auto [x, y] = measure(obj4);        // don't; it's likely to be confusing\n\nThe overly generic `pair` and `tuple` should be used only when the value returned represents independent entities rather than an abstraction.\n\nAnother option is to use `optional<T>` or `expected<T, error_code>`, rather than `pair` or `tuple`.\nWhen used appropriately these types convey more information about what the members mean than `pair<T, bool>` or `pair<T, error_code>` do.\n\n##### Note\n\nWhen the object to be returned is initialized from local variables that are expensive to copy,\nexplicit `move` may be helpful to avoid copying:\n\n    pair<LargeObject, LargeObject> f(const string& input)\n    {\n        LargeObject large1 = g(input);\n        LargeObject large2 = h(input);\n        // ...\n        return { move(large1), move(large2) }; // no copies\n    }\n\nAlternatively,\n\n    pair<LargeObject, LargeObject> f(const string& input)\n    {\n        // ...\n        return { g(input), h(input) }; // no copies, no moves\n    }\n\nNote this is different from the `return move(...)` anti-pattern from [ES.56](#res-move).\n\n##### Enforcement\n\n* Output parameters should be replaced by return values.\n  An output parameter is one that the function writes to, invokes a non-`const` member function, or passes on as a non-`const`.\n* `pair` or `tuple` return types should be replaced by `struct`, if possible.\n  In variadic templates, `tuple` is often unavoidable.\n\n### <a name=\"rf-ptr-ref\"></a>F.60: Prefer `T*` over `T&` when \"no argument\" is a valid option\n\n##### Reason\n\nA pointer (`T*`) can be a `nullptr` and a reference (`T&`) cannot, there is no valid \"null reference\".\nSometimes having `nullptr` as an alternative to indicated \"no object\" is useful, but if it is not, a reference is notationally simpler and might yield better code.\n\n##### Example\n\n    string zstring_to_string(zstring p) // zstring is a char*; that is a C-style string\n    {\n        if (!p) return string{};    // p might be nullptr; remember to check\n        return string{p};\n    }\n\n    void print(const vector<int>& r)\n    {\n        // r refers to a vector<int>; no check needed\n    }\n\n##### Note\n\nIt is possible, but not valid C++ to construct a reference that is essentially a `nullptr` (e.g., `T* p = nullptr; T& r = *p;`).\nThat error is very uncommon.\n\n##### Note\n\nIf you prefer the pointer notation (`->` and/or `*` vs. `.`), `not_null<T*>` provides the same guarantee as `T&`.\n\n##### Enforcement\n\n* Flag ???\n\n### <a name=\"rf-ptr\"></a>F.22: Use `T*` or `owner<T*>` to designate a single object\n\n##### Reason\n\nReadability: it makes the meaning of a plain pointer clear.\nEnables significant tool support.\n\n##### Note\n\nIn traditional C and C++ code, plain `T*` is used for many weakly-related purposes, such as:\n\n* Identify a (single) object (not to be deleted by this function)\n* Point to an object allocated on the free store (and delete it later)\n* Hold the `nullptr`\n* Identify a C-style string (zero-terminated array of characters)\n* Identify an array with a length specified separately\n* Identify a location in an array\n\nThis makes it hard to understand what the code does and is supposed to do.\nIt complicates checking and tool support.\n\n##### Example\n\n    void use(int* p, int n, char* s, int* q)\n    {\n        p[n - 1] = 666; // Bad: we don't know if p points to n elements;\n                        // assume it does not or use span<int>\n        cout << s;      // Bad: we don't know if that s points to a zero-terminated array of char;\n                        // assume it does not or use zstring\n        delete q;       // Bad: we don't know if *q is allocated on the free store;\n                        // assume it does not or use owner\n    }\n\nbetter\n\n    void use2(span<int> p, zstring s, owner<int*> q)\n    {\n        p[p.size() - 1] = 666; // OK, a range error can be caught\n        cout << s; // OK\n        delete q;  // OK\n    }\n\n##### Note\n\n`owner<T*>` represents ownership, `zstring` represents a C-style string.\n\n**Also**: Assume that a `T*` obtained from a smart pointer to `T` (e.g., `unique_ptr<T>`) points to a single element.\n\n**See also**: [Support library](#gsl-guidelines-support-library)\n\n**See also**: [Do not pass an array as a single pointer](#ri-array)\n\n##### Enforcement\n\n* (Simple) ((Bounds)) Warn for any arithmetic operation on an expression of pointer type that results in a value of pointer type.\n\n### <a name=\"rf-nullptr\"></a>F.23: Use a `not_null<T>` to indicate that \"null\" is not a valid value\n\n##### Reason\n\nClarity. A function with a `not_null<T>` parameter makes it clear that the caller of the function is responsible for any `nullptr` checks that might be necessary.\nSimilarly, a function with a return value of `not_null<T>` makes it clear that the caller of the function does not need to check for `nullptr`.\n\n##### Example\n\n`not_null<T*>` makes it obvious to a reader (human or machine) that a test for `nullptr` is not necessary before dereference.\nAdditionally, when debugging, `owner<T*>` and `not_null<T>` can be instrumented to check for correctness.\n\nConsider:\n\n    int length(Record* p);\n\nWhen I call `length(p)` should I check if `p` is `nullptr` first? Should the implementation of `length()` check if `p` is `nullptr`?\n\n    // it is the caller's job to make sure p != nullptr\n    int length(not_null<Record*> p);\n\n    // the implementor of length() must assume that p == nullptr is possible\n    int length(Record* p);\n\n##### Note\n\nA `not_null<T*>` is assumed not to be the `nullptr`; a `T*` might be the `nullptr`; both can be represented in memory as a `T*` (so no run-time overhead is implied).\n\n##### Note\n\n`not_null` is not just for built-in pointers. It works for `unique_ptr`, `shared_ptr`, and other pointer-like types.\n\n##### Enforcement\n\n* (Simple) Warn if a raw pointer is dereferenced without being tested against `nullptr` (or equivalent) within a function, suggest it is declared `not_null` instead.\n* (Simple) Error if a raw pointer is sometimes dereferenced after first being tested against `nullptr` (or equivalent) within the function and sometimes is not.\n* (Simple) Warn if a `not_null` pointer is tested against `nullptr` within a function.\n\n### <a name=\"rf-range\"></a>F.24: Use a `span<T>` or a `span_p<T>` to designate a half-open sequence\n\n##### Reason\n\nInformal/non-explicit ranges are a source of errors.\n\n##### Example\n\n    X* find(span<X> r, const X& v);    // find v in r\n\n    vector<X> vec;\n    // ...\n    auto p = find({vec.begin(), vec.end()}, X{});  // find X{} in vec\n\n##### Note\n\nRanges are extremely common in C++ code. Typically, they are implicit and their correct use is very hard to ensure.\nIn particular, given a pair of arguments `(p, n)` designating an array `[p:p+n)`,\nit is in general impossible to know if there really are `n` elements to access following `*p`.\n`span<T>` and `span_p<T>` are simple helper classes designating a `[p:q)` range and a range starting with `p` and ending with the first element for which a predicate is true, respectively.\n\n##### Example\n\nA `span` represents a range of elements, but how do we manipulate elements of that range?\n\n    void f(span<int> s)\n    {\n        // range traversal (guaranteed correct)\n        for (int x : s) cout << x << '\\n';\n\n        // C-style traversal (potentially checked)\n        for (gsl::index i = 0; i < s.size(); ++i) cout << s[i] << '\\n';\n\n        // random access (potentially checked)\n        s[7] = 9;\n\n        // extract pointers (potentially checked)\n        std::sort(&s[0], &s[s.size() / 2]);\n    }\n\n##### Note\n\nA `span<T>` object does not own its elements and is so small that it can be passed by value.\n\nPassing a `span` object as an argument is exactly as efficient as passing a pair of pointer arguments or passing a pointer and an integer count.\n\n**See also**: [Support library](#gsl-guidelines-support-library)\n\n##### Enforcement\n\n(Complex) Warn where accesses to pointer parameters are bounded by other parameters that are integral types and suggest they could use `span` instead.\n\n### <a name=\"rf-zstring\"></a>F.25: Use a `zstring` or a `not_null<zstring>` to designate a C-style string\n\n##### Reason\n\nC-style strings are ubiquitous. They are defined by convention: zero-terminated arrays of characters.\nWe must distinguish C-style strings from a pointer to a single character or an old-fashioned pointer to an array of characters.\n\nIf you don't need null termination, use `string_view`.\n\n##### Example\n\nConsider:\n\n    int length(const char* p);\n\nWhen I call `length(s)` should I check if `s` is `nullptr` first? Should the implementation of `length()` check if `p` is `nullptr`?\n\n    // the implementor of length() must assume that p == nullptr is possible\n    int length(zstring p);\n\n    // it is the caller's job to make sure p != nullptr\n    int length(not_null<zstring> p);\n\n##### Note\n\n`zstring` does not represent ownership.\n\n**See also**: [Support library](#gsl-guidelines-support-library)\n\n### <a name=\"rf-unique_ptr\"></a>F.26: Use a `unique_ptr<T>` to transfer ownership where a pointer is needed\n\n##### Reason\n\nUsing `unique_ptr` is the cheapest way to pass a pointer safely.\n\n**See also**: [C.50](#rc-factory) regarding when to return a `shared_ptr` from a factory.\n\n##### Example\n\n    unique_ptr<Shape> get_shape(istream& is)  // assemble shape from input stream\n    {\n        auto kind = read_header(is); // read header and identify the next shape on input\n        switch (kind) {\n        case kCircle:\n            return make_unique<Circle>(is);\n        case kTriangle:\n            return make_unique<Triangle>(is);\n        // ...\n        }\n    }\n\n##### Note\n\nYou need to pass a pointer rather than an object if what you are transferring is an object from a class hierarchy that is to be used through an interface (base class).\n\n##### Enforcement\n\n(Simple) Warn if a function returns a locally allocated raw pointer. Suggest using either `unique_ptr` or `shared_ptr` instead.\n\n### <a name=\"rf-shared_ptr\"></a>F.27: Use a `shared_ptr<T>` to share ownership\n\n##### Reason\n\nUsing `std::shared_ptr` is the standard way to represent shared ownership. That is, the last owner deletes the object.\n\n##### Example\n\n    {\n        shared_ptr<const Image> im { read_image(somewhere) };\n\n        std::thread t0 {shade, args0, top_left, im};\n        std::thread t1 {shade, args1, top_right, im};\n        std::thread t2 {shade, args2, bottom_left, im};\n        std::thread t3 {shade, args3, bottom_right, im};\n\n        // detaching threads requires extra care (e.g., to join before\n        // main ends), but even if we do detach the four threads here ...\n    }\n    // ... shared_ptr ensures that eventually the last thread to\n    //     finish safely deletes the image\n\n##### Note\n\nPrefer a `unique_ptr` over a `shared_ptr` if there is never more than one owner at a time.\n`shared_ptr` is for shared ownership.\n\nNote that pervasive use of `shared_ptr` has a cost (atomic operations on the `shared_ptr`'s reference count have a measurable aggregate cost).\n\n##### Alternative\n\nHave a single object own the shared object (e.g. a scoped object) and destroy that (preferably implicitly) when all users have completed.\n\n##### Enforcement\n\n(Not enforceable) This is a too complex pattern to reliably detect.\n\n### <a name=\"rf-return-ptr\"></a>F.42: Return a `T*` to indicate a position (only)\n\n##### Reason\n\nThat's what pointers are good for.\nReturning a `T*` to transfer ownership is a misuse.\n\n##### Example\n\n    Node* find(Node* t, const string& s)  // find s in a binary tree of Nodes\n    {\n        if (!t || t->name == s) return t;\n        if ((auto p = find(t->left, s))) return p;\n        if ((auto p = find(t->right, s))) return p;\n        return nullptr;\n    }\n\nIf it isn't the `nullptr`, the pointer returned by `find` indicates a `Node` holding `s`.\nImportantly, that does not imply a transfer of ownership of the pointed-to object to the caller.\n\n##### Note\n\nPositions can also be transferred by iterators, indices, and references.\nA reference is often a superior alternative to a pointer [if there is no need to use `nullptr`](#rf-ptr-ref) or [if the object referred to should not change](#s-const).\n\n##### Note\n\nDo not return a pointer to something that is not in the caller's scope; see [F.43](#rf-dangle).\n\n**See also**: [discussion of dangling pointer prevention](#???)\n\n##### Enforcement\n\n* Flag `delete`, `std::free()`, etc. applied to a plain `T*`.\nOnly owners should be deleted.\n* Flag `new`, `malloc()`, etc. assigned to a plain `T*`.\nOnly owners should be responsible for deletion.\n\n### <a name=\"rf-dangle\"></a>F.43: Never (directly or indirectly) return a pointer or a reference to a local object\n\n##### Reason\n\nTo avoid the crashes and data corruption that can result from the use of such a dangling pointer.\n\n##### Example, bad\n\nAfter the return from a function its local objects no longer exist:\n\n    int* f()\n    {\n        int fx = 9;\n        return &fx;  // BAD\n    }\n\n    void g(int* p)   // looks innocent enough\n    {\n        int gx;\n        cout << \"*p == \" << *p << '\\n';\n        *p = 999;\n        cout << \"gx == \" << gx << '\\n';\n    }\n\n    void h()\n    {\n        int* p = f();\n        int z = *p;  // read from abandoned stack frame (bad)\n        g(p);        // pass pointer to abandoned stack frame to function (bad)\n    }\n\nHere on one popular implementation I got the output:\n\n    *p == 999\n    gx == 999\n\nI expected that because the call of `g()` reuses the stack space abandoned by the call of `f()` so `*p` refers to the space now occupied by `gx`.\n\n* Imagine what would happen if `fx` and `gx` were of different types.\n* Imagine what would happen if `fx` or `gx` was a type with an invariant.\n* Imagine what would happen if that dangling pointer was passed around among a larger set of functions.\n* Imagine what a cracker could do with that dangling pointer.\n\nFortunately, most (all?) modern compilers catch and warn against this simple case.\n\n##### Note\n\nThis applies to references as well:\n\n    int& f()\n    {\n        int x = 7;\n        // ...\n        return x;  // Bad: returns reference to object that is about to be destroyed\n    }\n\n##### Note\n\nThis applies only to non-`static` local variables.\nAll `static` variables are (as their name indicates) statically allocated, so that pointers to them cannot dangle.\n\n##### Example, bad\n\nNot all examples of leaking a pointer to a local variable are that obvious:\n\n    int* glob;       // global variables are bad in so many ways\n\n    template<class T>\n    void steal(T x)\n    {\n        glob = x();  // BAD\n    }\n\n    void f()\n    {\n        int i = 99;\n        steal([&] { return &i; });\n    }\n\n    int main()\n    {\n        f();\n        cout << *glob << '\\n';\n    }\n\nHere I managed to read the location abandoned by the call of `f`.\nThe pointer stored in `glob` could be used much later and cause trouble in unpredictable ways.\n\n##### Note\n\nThe address of a local variable can be \"returned\"/leaked by a return statement, by a `T&` out-parameter, as a member of a returned object, as an element of a returned array, and more.\n\n##### Note\n\nSimilar examples can be constructed \"leaking\" a pointer from an inner scope to an outer one;\nsuch examples are handled equivalently to leaks of pointers out of a function.\n\nA slightly different variant of the problem is placing pointers in a container that outlives the objects pointed to.\n\n**See also**: Another way of getting dangling pointers is [pointer invalidation](#???).\nIt can be detected/prevented with similar techniques.\n\n##### Enforcement\n\n* Compilers tend to catch return of reference to locals and could in many cases catch return of pointers to locals.\n* Static analysis can catch many common patterns of the use of pointers indicating positions (thus eliminating dangling pointers)\n\n### <a name=\"rf-return-ref\"></a>F.44: Return a `T&` when copy is undesirable and \"returning no object\" isn't needed\n\n##### Reason\n\nThe language guarantees that a `T&` refers to an object, so that testing for `nullptr` isn't necessary.\n\n**See also**: The return of a reference must not imply transfer of ownership:\n[discussion of dangling pointer prevention](#???) and [discussion of ownership](#???).\n\n##### Example\n\n    class Car\n    {\n        array<wheel, 4> w;\n        // ...\n    public:\n        wheel& get_wheel(int i) { Expects(i < w.size()); return w[i]; }\n        // ...\n    };\n\n    void use()\n    {\n        Car c;\n        wheel& w0 = c.get_wheel(0); // w0 has the same lifetime as c\n    }\n\n##### Enforcement\n\nFlag functions where no `return` expression could yield `nullptr`.\n\n### <a name=\"rf-return-ref-ref\"></a>F.45: Don't return a `T&&`\n\n##### Reason\n\nIt's asking to return a reference to a destroyed temporary object.\nAn `&&` is a magnet for temporary objects.\n\n##### Example\n\nA returned rvalue reference goes out of scope at the end of the full expression to which it is returned:\n\n    auto&& x = max(0, 1);   // OK, so far\n    foo(x);                 // Undefined behavior\n\nThis kind of use is a frequent source of bugs, often incorrectly reported as a compiler bug.\nAn implementer of a function should avoid setting such traps for users.\n\nThe [lifetime safety profile](#ss-lifetime) will (when completely implemented) catch such problems.\n\n\n##### Example\n\nReturning an rvalue reference is fine when the reference to the temporary is being passed \"downward\" to a callee;\nthen, the temporary is guaranteed to outlive the function call (see [F.18](#rf-consume) and [F.19](#rf-forward)).\nHowever, it's not fine when passing such a reference \"upward\" to a larger caller scope.\nFor passthrough functions that pass in parameters (by ordinary reference or by perfect forwarding) and want to return values, use simple `auto` return type deduction (not `auto&&`).\n\nAssume that `F` returns by value:\n\n    template<class F>\n    auto&& wrapper(F f)\n    {\n        log_call(typeid(f)); // or whatever instrumentation\n        return f();          // BAD: returns a reference to a temporary\n    }\n\nBetter:\n\n    template<class F>\n    auto wrapper(F f)\n    {\n        log_call(typeid(f)); // or whatever instrumentation\n        return f();          // OK\n    }\n\n\n##### Exception\n\n`std::move` and `std::forward` do return `&&`, but they are just casts -- used by convention only in expression contexts where a reference to a temporary object is passed along within the same expression before the temporary is destroyed. We don't know of any other good examples of returning `&&`.\n\n##### Enforcement\n\nFlag any use of `&&` as a return type, except in `std::move` and `std::forward`.\n\n### <a name=\"rf-main\"></a>F.46: `int` is the return type for `main()`\n\n##### Reason\n\nIt's a language rule, but violated through \"language extensions\" so often that it is worth mentioning.\nDeclaring `main` (the one global `main` of a program) `void` limits portability.\n\n##### Example\n\n        void main() { /* ... */ };  // bad, not C++\n\n        int main()\n        {\n            std::cout << \"This is the way to do it\\n\";\n        }\n\n##### Note\n\nWe mention this only because of the persistence of this error in the community.\nNote that despite its non-void return type, the main function does not require an explicit return statement.\n\n##### Enforcement\n\n* The compiler should do it\n* If the compiler doesn't do it, let tools flag it\n\n### <a name=\"rf-assignment-op\"></a>F.47: Return `T&` from assignment operators\n\n##### Reason\n\nThe convention for operator overloads (especially on concrete types) is for\n`operator=(const T&)` to perform the assignment and then return (non-`const`)\n`*this`.  This ensures consistency with standard-library types and follows the\nprinciple of \"do as the ints do.\"\n\n##### Note\n\nHistorically there was some guidance to make the assignment operator return `const T&`.\nThis was primarily to avoid code of the form `(a = b) = c` -- such code is not common enough to warrant violating consistency with standard types.\n\n##### Example\n\n    class Foo\n    {\n     public:\n        ...\n        Foo& operator=(const Foo& rhs)\n        {\n          // Copy members.\n          ...\n          return *this;\n        }\n    };\n\n##### Enforcement\n\nThis should be enforced by tooling by checking the return type (and return\nvalue) of any assignment operator.\n\n### <a name=\"rf-return-move-local\"></a>F.48: Don't `return std::move(local)`\n\n##### Reason\n\nReturning a local variable implicitly moves it anyway.\nAn explicit `std::move` is always a pessimization, because it prevents Return Value Optimization (RVO),\nwhich can eliminate the move completely.\n\n##### Example, bad\n\n    S bad()\n    {\n      S result;\n      return std::move(result);\n    }\n\n##### Example, good\n\n    S good()\n    {\n      S result;\n      // Named RVO: move elision at best, move construction at worst\n      return result;\n    }\n\n##### Enforcement\n\nThis should be enforced by tooling by checking the return expression.\n\n### <a name=\"rf-return-const\"></a>F.49: Don't return `const T`\n\n##### Reason\n\nIt is not recommended to return a `const` value.\nSuch older advice is now obsolete; it does not add value, and it interferes with move semantics.\n\n##### Example\n\n    const vector<int> fct();    // bad: that \"const\" is more trouble than it is worth\n\n    void g(vector<int>& vx)\n    {\n        // ...\n        fct() = vx;   // prevented by the \"const\"\n        // ...\n        vx = fct(); // expensive copy: move semantics suppressed by the \"const\"\n        // ...\n    }\n\nThe argument for adding `const` to a return value is that it prevents (very rare) accidental access to a temporary.\nThe argument against is that it prevents (very frequent) use of move semantics.\n\n**See also**: [F.20, the general item about \"out\" output values](#rf-out)\n\n##### Enforcement\n\n* Flag returning a `const` value. To fix: Remove `const` to return a non-`const` value instead.\n\n\n### <a name=\"rf-capture-vs-overload\"></a>F.50: Use a lambda when a function won't do (to capture local variables, or to write a local function)\n\n##### Reason\n\nFunctions can't capture local variables or be defined at local scope; if you need those things, prefer a lambda where possible, and a handwritten function object where not. On the other hand, lambdas and function objects don't overload; if you need to overload, prefer a function (the workarounds to make lambdas overload are ornate). If either will work, prefer writing a function; use the simplest tool necessary.\n\n##### Example\n\n    // writing a function that should only take an int or a string\n    // -- overloading is natural\n    void f(int);\n    void f(const string&);\n\n    // writing a function object that needs to capture local state and appear\n    // at statement or expression scope -- a lambda is natural\n    vector<work> v = lots_of_work();\n    for (int tasknum = 0; tasknum < max; ++tasknum) {\n        pool.run([=, &v] {\n            /*\n            ...\n            ... process (1/max)-th of v, the tasknum-th chunk\n            ...\n            */\n        });\n    }\n    pool.join();\n\n##### Exception\n\nGeneric lambdas offer a concise way to write function templates and so can be useful even when a normal function template would do equally well with a little more syntax. This advantage will probably disappear in the future once all functions gain the ability to have Concept parameters.\n\n##### Enforcement\n\n* Warn on use of a named non-generic lambda (e.g., `auto x = [](int i) { /*...*/; };`) that captures nothing and appears at global scope. Write an ordinary function instead.\n\n### <a name=\"rf-default-args\"></a>F.51: Where there is a choice, prefer default arguments over overloading\n\n##### Reason\n\nDefault arguments simply provide alternative interfaces to a single implementation.\nThere is no guarantee that a set of overloaded functions all implement the same semantics.\nThe use of default arguments can avoid code replication.\n\n##### Note\n\nThere is a choice between using default argument and overloading when the alternatives are from a set of arguments of the same types.\nFor example:\n\n    void print(const string& s, format f = {});\n\nas opposed to\n\n    void print(const string& s);  // use default format\n    void print(const string& s, format f);\n\nThere is not a choice when a set of functions are used to do a semantically equivalent operation to a set of types. For example:\n\n    void print(const char&);\n    void print(int);\n    void print(zstring);\n\n##### See also\n\n\n[Default arguments for virtual functions](#rh-virtual-default-arg)\n\n##### Enforcement\n\n* Warn on an overload set where the overloads have a common prefix of parameters (e.g., `f(int)`, `f(int, const string&)`, `f(int, const string&, double)`). (Note: Review this enforcement if it's too noisy in practice.)\n\n### <a name=\"rf-reference-capture\"></a>F.52: Prefer capturing by reference in lambdas that will be used locally, including passed to algorithms\n\n##### Reason\n\nFor efficiency and correctness, you nearly always want to capture by reference when using the lambda locally. This includes when writing or calling parallel algorithms that are local because they join before returning.\n\n##### Discussion\n\nThe efficiency consideration is that most types are cheaper to pass by reference than by value.\n\nThe correctness consideration is that many calls want to perform side effects on the original object at the call site (see example below). Passing by value prevents this.\n\n##### Note\n\nUnfortunately, there is no simple way to capture by reference to `const` to get the efficiency for a local call but also prevent side effects.\n\n##### Example\n\nHere, a large object (a network message) is passed to an iterative algorithm, and it is not efficient or correct to copy the message (which might not be copyable):\n\n    std::for_each(begin(sockets), end(sockets), [&message](auto& socket)\n    {\n        socket.send(message);\n    });\n\n##### Example\n\nThis is a simple three-stage parallel pipeline. Each `stage` object encapsulates a worker thread and a queue, has a `process` function to enqueue work, and in its destructor automatically blocks waiting for the queue to empty before ending the thread.\n\n    void send_packets(buffers& bufs)\n    {\n        stage encryptor([](buffer& b) { encrypt(b); });\n        stage compressor([&](buffer& b) { compress(b); encryptor.process(b); });\n        stage decorator([&](buffer& b) { decorate(b); compressor.process(b); });\n        for (auto& b : bufs) { decorator.process(b); }\n    }  // automatically blocks waiting for pipeline to finish\n\n##### Enforcement\n\nFlag a lambda that captures by reference, but is used other than locally within the function scope or passed to a function by reference. (Note: This rule is an approximation, but does flag passing by pointer as those are more likely to be stored by the callee, writing to a heap location accessed via a parameter, returning the lambda, etc. The Lifetime rules will also provide general rules that flag escaping pointers and references including via lambdas.)\n\n### <a name=\"rf-value-capture\"></a>F.53: Avoid capturing by reference in lambdas that will be used non-locally, including returned, stored on the heap, or passed to another thread\n\n##### Reason\n\nPointers and references to locals shouldn't outlive their scope. Lambdas that capture by reference are just another place to store a reference to a local object, and shouldn't do so if they (or a copy) outlive the scope.\n\n##### Example, bad\n\n    int local = 42;\n\n    // Want a reference to local.\n    // Note that after program exits this scope,\n    // local no longer exists, therefore\n    // process() call will have undefined behavior!\n    thread_pool.queue_work([&] { process(local); });\n\n##### Example, good\n\n    int local = 42;\n    // Want a copy of local.\n    // Since a copy of local is made, it will\n    // always be available for the call.\n    thread_pool.queue_work([=] { process(local); });\n\n##### Note\n\nIf a non-local pointer must be captured, consider using `unique_ptr`; this handles both lifetime and synchronization.\n\nIf the `this` pointer must be captured, consider using `[*this]` capture, which creates a copy of the entire object.\n\n##### Enforcement\n\n* (Simple) Warn when capture-list contains a reference to a locally declared variable\n* (Complex) Flag when capture-list contains a reference to a locally declared variable and the lambda is passed to a non-`const` and non-local context\n\n### <a name=\"rf-this-capture\"></a>F.54: When writing a lambda that captures `this` or any class data member, don't use `[=]` default capture\n\n##### Reason\n\nIt's confusing. Writing `[=]` in a member function appears to capture by value, but actually captures data members by reference because it actually captures the invisible `this` pointer by value. If you meant to do that, write `this` explicitly.\n\n##### Example\n\n    class My_class {\n        int x = 0;\n        // ...\n\n        void f()\n        {\n            int i = 0;\n            // ...\n\n            auto lambda = [=] { use(i, x); };   // BAD: \"looks like\" copy/value capture\n\n            x = 42;\n            lambda(); // calls use(0, 42);\n            x = 43;\n            lambda(); // calls use(0, 43);\n\n            // ...\n\n            auto lambda2 = [i, this] { use(i, x); }; // ok, most explicit and least confusing\n\n            // ...\n        }\n    };\n\n##### Note\n\nIf you intend to capture a copy of all class data members, consider C++17 `[*this]`.\n\n##### Enforcement\n\n* Flag any lambda capture-list that specifies a capture-default of `[=]` and also captures `this` (whether explicitly or via the default capture and a use of `this` in the body)\n\n### <a name=\"f-varargs\"></a>F.55: Don't use `va_arg` arguments\n\n##### Reason\n\nReading from a `va_arg` assumes that the correct type was actually passed.\nPassing to varargs assumes the correct type will be read.\nThis is fragile because it cannot generally be enforced to be safe in the language and so relies on programmer discipline to get it right.\n\n##### Example\n\n    int sum(...)\n    {\n        // ...\n        while (/*...*/)\n            result += va_arg(list, int); // BAD, assumes it will be passed ints\n        // ...\n    }\n\n    sum(3, 2); // ok\n    sum(3.14159, 2.71828); // BAD, undefined\n\n    template<class ...Args>\n    auto sum(Args... args) // GOOD, and much more flexible\n    {\n        return (... + args); // note: C++17 \"fold expression\"\n    }\n\n    sum(3, 2); // ok: 5\n    sum(3.14159, 2.71828); // ok: ~5.85987\n\n##### Alternatives\n\n* overloading\n* variadic templates\n* `variant` arguments\n* `initializer_list` (homogeneous)\n\n##### Note\n\nDeclaring a `...` parameter is sometimes useful for techniques that don't involve actual argument passing, notably to declare \"take-anything\" functions so as to disable \"everything else\" in an overload set or express a catchall case in a template metaprogram.\n\n##### Enforcement\n\n* Issue a diagnostic for using `va_list`, `va_start`, or `va_arg`.\n* Issue a diagnostic for passing an argument to a vararg parameter of a function that does not offer an overload for a more specific type in the position of the vararg. To fix: Use a different function, or `[[suppress(\"type\")]]`.\n\n\n### <a name=\"f-nesting\"></a>F.56: Avoid unnecessary condition nesting\n\n##### Reason\n\nShallow nesting of conditions makes the code easier to follow. It also makes the intent clearer.\nStrive to place the essential code at outermost scope, unless this obscures intent.\n\n##### Example\n\nUse a guard-clause to take care of exceptional cases and return early.\n\n    // Bad: Deep nesting\n    void foo() {\n        ...\n        if (x) {\n            computeImportantThings(x);\n        }\n    }\n\n    // Bad: Still a redundant else.\n    void foo() {\n        ...\n        if (!x) {\n            return;\n        }\n        else {\n            computeImportantThings(x);\n        }\n    }\n\n    // Good: Early return, no redundant else\n    void foo() {\n        ...\n        if (!x)\n            return;\n\n        computeImportantThings(x);\n    }\n\n##### Example\n\n    // Bad: Unnecessary nesting of conditions\n    void foo() {\n        ...\n        if (x) {\n            if (y) {\n                computeImportantThings(x);\n            }\n        }\n    }\n\n    // Good: Merge conditions + return early\n    void foo() {\n        ...\n        if (!(x && y))\n            return;\n\n        computeImportantThings(x);\n    }\n\n##### Enforcement\n\nFlag a redundant `else`.\nFlag a function whose body is simply a conditional statement enclosing a block.\n\n\n# <a name=\"s-class\"></a>C: Classes and class hierarchies\n\nA class is a user-defined type, for which a programmer can define the representation, operations, and interfaces.\nClass hierarchies are used to organize related classes into hierarchical structures.\n\nClass rule summary:\n\n* [C.1: Organize related data into structures (`struct`s or `class`es)](#rc-org)\n* [C.2: Use `class` if the class has an invariant; use `struct` if the data members can vary independently](#rc-struct)\n* [C.3: Represent the distinction between an interface and an implementation using a class](#rc-interface)\n* [C.4: Make a function a member only if it needs direct access to the representation of a class](#rc-member)\n* [C.5: Place helper functions in the same namespace as the class they support](#rc-helper)\n* [C.7: Don't define a class or enum and declare a variable of its type in the same statement](#rc-standalone)\n* [C.8: Use `class` rather than `struct` if any member is non-public](#rc-class)\n* [C.9: Minimize exposure of members](#rc-private)\n\nSubsections:\n\n* [C.concrete: Concrete types](#ss-concrete)\n* [C.ctor: Constructors, assignments, and destructors](#s-ctor)\n* [C.con: Containers and other resource handles](#ss-containers)\n* [C.lambdas: Function objects and lambdas](#ss-lambdas)\n* [C.hier: Class hierarchies (OOP)](#ss-hier)\n* [C.over: Overloading and overloaded operators](#ss-overload)\n* [C.union: Unions](#ss-union)\n\n### <a name=\"rc-org\"></a>C.1: Organize related data into structures (`struct`s or `class`es)\n\n##### Reason\n\nEase of comprehension.\nIf data is related (for fundamental reasons), that fact should be reflected in code.\n\n##### Example\n\n    void draw(int x, int y, int x2, int y2);  // BAD: unnecessary implicit relationships\n    void draw(Point from, Point to);          // better\n\n##### Note\n\nA simple class without virtual functions implies no space or time overhead.\n\n##### Note\n\nFrom a language perspective `class` and `struct` differ only in the default visibility of their members.\n\n##### Enforcement\n\nProbably impossible. Maybe a heuristic looking for data items used together is possible.\n\n### <a name=\"rc-struct\"></a>C.2: Use `class` if the class has an invariant; use `struct` if the data members can vary independently\n\n##### Reason\n\nReadability.\nEase of comprehension.\nThe use of `class` alerts the programmer to the need for an invariant.\nThis is a useful convention.\n\n##### Note\n\nAn invariant is a logical condition for the members of an object that a constructor must establish for the public member functions to assume.\nAfter the invariant is established (typically by a constructor) every member function can be called for the object.\nAn invariant can be stated informally (e.g., in a comment) or more formally using `Expects`.\n\nIf all data members can vary independently of each other, no invariant is possible.\n\n##### Example\n\n    struct Pair {  // the members can vary independently\n        string name;\n        int volume;\n    };\n\nbut:\n\n    class Date {\n    public:\n        // validate that {yy, mm, dd} is a valid date and initialize\n        Date(int yy, Month mm, char dd);\n        // ...\n    private:\n        int y;\n        Month m;\n        char d;    // day\n    };\n\n##### Note\n\nIf a class has any `private` data, a user cannot completely initialize an object without the use of a constructor.\nHence, the class definer will provide a constructor and must specify its meaning.\nThis effectively means the definer needs to define an invariant.\n\n**See also**:\n\n* [define a class with private data as `class`](#rc-class)\n* [Prefer to place the interface first in a class](#rl-order)\n* [minimize exposure of members](#rc-private)\n* [Avoid `protected` data](#rh-protected)\n\n##### Enforcement\n\nLook for `struct`s with all data private and `class`es with public members.\n\n### <a name=\"rc-interface\"></a>C.3: Represent the distinction between an interface and an implementation using a class\n\n##### Reason\n\nAn explicit distinction between interface and implementation improves readability and simplifies maintenance.\n\n##### Example\n\n    class Date {\n    public:\n        Date();\n        // validate that {yy, mm, dd} is a valid date and initialize\n        Date(int yy, Month mm, char dd);\n\n        int day() const;\n        Month month() const;\n        // ...\n    private:\n        // ... some representation ...\n    };\n\nFor example, we can now change the representation of a `Date` without affecting its users (recompilation is likely, though).\n\n##### Note\n\nUsing a class in this way to represent the distinction between interface and implementation is of course not the only way.\nFor example, we can use a set of declarations of freestanding functions in a namespace, an abstract base class, or a function template with concepts to represent an interface.\nThe most important issue is to explicitly distinguish between an interface and its implementation \"details.\"\nIdeally, and typically, an interface is far more stable than its implementation(s).\n\n##### Enforcement\n\n???\n\n### <a name=\"rc-member\"></a>C.4: Make a function a member only if it needs direct access to the representation of a class\n\n##### Reason\n\nLess coupling than with member functions, fewer functions that can cause trouble by modifying object state, reduces the number of functions that need to be modified after a change in representation.\n\n##### Example\n\n    class Date {\n        // ... relatively small interface ...\n    };\n\n    // helper functions:\n    Date next_weekday(Date);\n    bool operator==(Date, Date);\n\nThe \"helper functions\" have no need for direct access to the representation of a `Date`.\n\n##### Note\n\nThis rule becomes even better if C++ gets [\"uniform function call\"](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0251r0.pdf).\n\n##### Exception\n\nThe language requires `virtual` functions to be members, and not all `virtual` functions directly access data.\nIn particular, members of an abstract class rarely do.\n\nNote [multi-methods](https://web.archive.org/web/20200605021759/https://parasol.tamu.edu/~yuriys/papers/OMM10.pdf).\n\n##### Exception\n\nThe language requires operators `=`, `()`, `[]`, and `->` to be members.\n\n##### Exception\n\nAn overload set could have some members that do not directly access `private` data:\n\n    class Foobar {\n    public:\n        void foo(long x) { /* manipulate private data */ }\n        void foo(double x) { foo(std::lround(x)); }\n        // ...\n    private:\n        // ...\n    };\n\n##### Exception\n\nSimilarly, a set of functions could be designed to be used in a chain:\n\n    x.scale(0.5).rotate(45).set_color(Color::red);\n\nTypically, some but not all of such functions directly access `private` data.\n\n##### Enforcement\n\n* Look for non-`virtual` member functions that do not touch data members directly.\nThe snag is that many member functions that do not need to touch data members directly do.\n* Ignore `virtual` functions.\n* Ignore functions that are part of an overload set out of which at least one function accesses `private` members.\n* Ignore functions returning `this`.\n\n### <a name=\"rc-helper\"></a>C.5: Place helper functions in the same namespace as the class they support\n\n##### Reason\n\nA helper function is a function (usually supplied by the writer of a class) that does not need direct access to the representation of the class, yet is seen as part of the useful interface to the class.\nPlacing them in the same namespace as the class makes their relationship to the class obvious and allows them to be found by argument dependent lookup.\n\n##### Example\n\n    namespace Chrono { // here we keep time-related services\n\n        class Time { /* ... */ };\n        class Date { /* ... */ };\n\n        // helper functions:\n        bool operator==(Date, Date);\n        Date next_weekday(Date);\n        // ...\n    }\n\n##### Note\n\nThis is especially important for [overloaded operators](#ro-namespace).\n\n##### Enforcement\n\n* Flag global functions taking argument types from a single namespace.\n\n### <a name=\"rc-standalone\"></a>C.7: Don't define a class or enum and declare a variable of its type in the same statement\n\n##### Reason\n\nMixing a type definition and the definition of another entity in the same declaration is confusing and unnecessary.\n\n##### Example, bad\n\n    struct Data { /*...*/ } data{ /*...*/ };\n\n##### Example, good\n\n    struct Data { /*...*/ };\n    Data data{ /*...*/ };\n\n##### Enforcement\n\n* Flag if the `}` of a class or enumeration definition is not followed by a `;`. The `;` is missing.\n\n### <a name=\"rc-class\"></a>C.8: Use `class` rather than `struct` if any member is non-public\n\n##### Reason\n\nReadability.\nTo make it clear that something is being hidden/abstracted.\nThis is a useful convention.\n\n##### Example, bad\n\n    struct Date {\n        int d, m;\n\n        Date(int i, Month m);\n        // ... lots of functions ...\n    private:\n        int y;  // year\n    };\n\nThere is nothing wrong with this code as far as the C++ language rules are concerned,\nbut nearly everything is wrong from a design perspective.\nThe private data is hidden far from the public data.\nThe data is split in different parts of the class declaration.\nDifferent parts of the data have different access.\nAll of this decreases readability and complicates maintenance.\n\n##### Note\n\nPrefer to place the interface first in a class, [see NL.16](#rl-order).\n\n##### Enforcement\n\nFlag classes declared with `struct` if there is a `private` or `protected` member.\n\n### <a name=\"rc-private\"></a>C.9: Minimize exposure of members\n\n##### Reason\n\nEncapsulation.\nInformation hiding.\nMinimize the chance of unintended access.\nThis simplifies maintenance.\n\n##### Example\n\n    template<typename T, typename U>\n    struct pair {\n        T a;\n        U b;\n        // ...\n    };\n\nWhatever we do in the `//`-part, an arbitrary user of a `pair` can arbitrarily and independently change its `a` and `b`.\nIn a large code base, we cannot easily find which code does what to the members of `pair`.\nThis might be exactly what we want, but if we want to enforce a relation among members, we need to make them `private`\nand enforce that relation (invariant) through constructors and member functions.\nFor example:\n\n    class Distance {\n    public:\n        // ...\n        double meters() const { return magnitude*unit; }\n        void set_unit(double u)\n        {\n                // ... check that u is a factor of 10 ...\n                // ... change magnitude appropriately ...\n                unit = u;\n        }\n        // ...\n    private:\n        double magnitude;\n        double unit;    // 1 is meters, 1000 is kilometers, 0.001 is millimeters, etc.\n    };\n\n##### Note\n\nIf the set of direct users of a set of variables cannot be easily determined, the type or usage of that set cannot be (easily) changed/improved.\nFor `public` and `protected` data, that's usually the case.\n\n##### Example\n\nA class can provide two interfaces to its users.\nOne for derived classes (`protected`) and one for general users (`public`).\nFor example, a derived class might be allowed to skip a run-time check because it has already guaranteed correctness:\n\n    class Foo {\n    public:\n        int bar(int x) { check(x); return do_bar(x); }\n        // ...\n    protected:\n        int do_bar(int x); // do some operation on the data\n        // ...\n    private:\n        // ... data ...\n    };\n\n    class Dir : public Foo {\n        //...\n        int mem(int x, int y)\n        {\n            /* ... do something ... */\n            return do_bar(x + y); // OK: derived class can bypass check\n        }\n    };\n\n    void user(Foo& x)\n    {\n        int r1 = x.bar(1);      // OK, will check\n        int r2 = x.do_bar(2);   // error: would bypass check\n        // ...\n    }\n\n##### Note\n\n[`protected` data is a bad idea](#rh-protected).\n\n##### Note\n\nPrefer the order `public` members before `protected` members before `private` members; see [NL.16](#rl-order).\n\n##### Enforcement\n\n* [Flag protected data](#rh-protected).\n* Flag mixtures of `public` and `private` data\n\n## <a name=\"ss-concrete\"></a>C.concrete: Concrete types\n\nConcrete type rule summary:\n\n* [C.10: Prefer concrete types over class hierarchies](#rc-concrete)\n* [C.11: Make concrete types regular](#rc-regular)\n* [C.12: Don't make data members `const` or references in a copyable or movable type](#rc-constref)\n\n\n### <a name=\"rc-concrete\"></a>C.10: Prefer concrete types over class hierarchies\n\n##### Reason\n\nA concrete type is fundamentally simpler than a type in a class hierarchy:\neasier to design, easier to implement, easier to use, easier to reason about, smaller, and faster.\nYou need a reason (use cases) for using a hierarchy.\n\n##### Example\n\n    class Point1 {\n        int x, y;\n        // ... operations ...\n        // ... no virtual functions ...\n    };\n\n    class Point2 {\n        int x, y;\n        // ... operations, some virtual ...\n        virtual ~Point2();\n    };\n\n    void use()\n    {\n        Point1 p11 {1, 2};   // make an object on the stack\n        Point1 p12 {p11};    // a copy\n\n        auto p21 = make_unique<Point2>(1, 2);   // make an object on the free store\n        auto p22 = p21->clone();                // make a copy\n        // ...\n    }\n\nIf a class is part of a hierarchy, we (in real code if not necessarily in small examples) must manipulate its objects through pointers or references.\nThat implies more memory overhead, more allocations and deallocations, and more run-time overhead to perform the resulting indirections.\n\n##### Note\n\nConcrete types can be stack-allocated and be members of other classes.\n\n##### Note\n\nThe use of indirection is fundamental for run-time polymorphic interfaces.\nThe allocation/deallocation overhead is not (that's just the most common case).\nWe can use a base class as the interface of a scoped object of a derived class.\nThis is done where dynamic allocation is prohibited (e.g. hard-real-time) and to provide a stable interface to some kinds of plug-ins.\n\n\n##### Enforcement\n\n???\n\n\n### <a name=\"rc-regular\"></a>C.11: Make concrete types regular\n\n##### Reason\n\nRegular types are easier to understand and reason about than types that are not regular (irregularities require extra effort to understand and use).\n\nThe C++ built-in types are regular, and so are standard-library classes such as `string`, `vector`, and `map`. Concrete classes without assignment and equality can be defined, but they are (and should be) rare.\n\n##### Example\n\n    struct Bundle {\n        string name;\n        vector<Record> vr;\n    };\n\n    bool operator==(const Bundle& a, const Bundle& b)\n    {\n        return a.name == b.name && a.vr == b.vr;\n    }\n\n    Bundle b1 { \"my bundle\", {r1, r2, r3}};\n    Bundle b2 = b1;\n    if (!(b1 == b2)) error(\"impossible!\");\n    b2.name = \"the other bundle\";\n    if (b1 == b2) error(\"No!\");\n\nIn particular, if a concrete type is copyable, prefer to also give it an equality comparison operator, and ensure that `a = b` implies `a == b`.\n\n##### Note\n\nFor structs intended to be shared with C code, defining `operator==` may not be feasible.\n\n##### Note\n\nHandles for resources that cannot be cloned, e.g., a `scoped_lock` for a `mutex`, are concrete types but typically cannot be copied (instead, they can usually be moved),\nso they can't be regular; instead, they tend to be move-only.\n\n##### Enforcement\n\n???\n\n\n### <a name=\"rc-constref\"></a>C.12: Don't make data members `const` or references in a copyable or movable type\n\n##### Reason\n\n`const` and reference data members are not useful in a copyable or movable type, and make such types difficult to use by making them at least partly uncopyable/unmovable for subtle reasons.\n\n##### Example; bad\n\n    class bad {\n        const int i;    // bad\n        string& s;      // bad\n        // ...\n    };\n\nThe `const` and `&` data members make this class \"only-sort-of-copyable\" -- copy-constructible but not copy-assignable.\n\n##### Note\n\nIf you need a member to point to something, use a pointer (raw or smart, and `gsl::not_null` if it should not be null) instead of a reference.\n\n##### Enforcement\n\nFlag a data member that is `const`, `&`, or `&&` in a type that has any copy or move operation.\n\n\n\n## <a name=\"s-ctor\"></a>C.ctor: Constructors, assignments, and destructors\n\nThese functions control the lifecycle of objects: creation, copy, move, and destruction.\nDefine constructors to guarantee and simplify initialization of classes.\n\nThese are *default operations*:\n\n* a default constructor: `X()`\n* a copy constructor: `X(const X&)`\n* a copy assignment: `operator=(const X&)`\n* a move constructor: `X(X&&)`\n* a move assignment: `operator=(X&&)`\n* a destructor: `~X()`\n\nBy default, the compiler defines each of these operations if it is used, but the default can be suppressed.\n\nThe default operations are a set of related operations that together implement the lifecycle semantics of an object.\nBy default, C++ treats classes as value-like types, but not all types are value-like.\n\nSet of default operations rules:\n\n* [C.20: If you can avoid defining any default operations, do](#rc-zero)\n* [C.21: If you define or `=delete` any copy, move, or destructor function, define or `=delete` them all](#rc-five)\n* [C.22: Make default operations consistent](#rc-matched)\n\nDestructor rules:\n\n* [C.30: Define a destructor if a class needs an explicit action at object destruction](#rc-dtor)\n* [C.31: All resources acquired by a class must be released by the class's destructor](#rc-dtor-release)\n* [C.32: If a class has a raw pointer (`T*`) or reference (`T&`), consider whether it might be owning](#rc-dtor-ptr)\n* [C.33: If a class has an owning pointer member, define a destructor](#rc-dtor-ptr2)\n* [C.35: A base class destructor should be either public and virtual, or protected and non-virtual](#rc-dtor-virtual)\n* [C.36: A destructor must not fail](#rc-dtor-fail)\n* [C.37: Make destructors `noexcept`](#rc-dtor-noexcept)\n\nConstructor rules:\n\n* [C.40: Define a constructor if a class has an invariant](#rc-ctor)\n* [C.41: A constructor should create a fully initialized object](#rc-complete)\n* [C.42: If a constructor cannot construct a valid object, throw an exception](#rc-throw)\n* [C.43: Ensure that a copyable class has a default constructor](#rc-default0)\n* [C.44: Prefer default constructors to be simple and non-throwing](#rc-default00)\n* [C.45: Don't define a default constructor that only initializes data members; use member initializers instead](#rc-default)\n* [C.46: By default, declare single-argument constructors `explicit`](#rc-explicit)\n* [C.47: Define and initialize data members in the order of member declaration](#rc-order)\n* [C.48: Prefer default member initializers to member initializers in constructors for constant initializers](#rc-in-class-initializer)\n* [C.49: Prefer initialization to assignment in constructors](#rc-initialize)\n* [C.50: Use a factory function if you need \"virtual behavior\" during initialization](#rc-factory)\n* [C.51: Use delegating constructors to represent common actions for all constructors of a class](#rc-delegating)\n* [C.52: Use inheriting constructors to import constructors into a derived class that does not need further explicit initialization](#rc-inheriting)\n\nCopy and move rules:\n\n* [C.60: Make copy assignment non-`virtual`, take the parameter by `const&`, and return by non-`const&`](#rc-copy-assignment)\n* [C.61: A copy operation should copy](#rc-copy-semantic)\n* [C.62: Make copy assignment safe for self-assignment](#rc-copy-self)\n* [C.63: Make move assignment non-`virtual`, take the parameter by `&&`, and return by non-`const&`](#rc-move-assignment)\n* [C.64: A move operation should move and leave its source in a valid state](#rc-move-semantic)\n* [C.65: Make move assignment safe for self-assignment](#rc-move-self)\n* [C.66: Make move operations `noexcept`](#rc-move-noexcept)\n* [C.67: A polymorphic class should suppress public copy/move](#rc-copy-virtual)\n\nOther default operations rules:\n\n* [C.80: Use `=default` if you have to be explicit about using the default semantics](#rc-eqdefault)\n* [C.81: Use `=delete` when you want to disable default behavior (without wanting an alternative)](#rc-delete)\n* [C.82: Don't call virtual functions in constructors and destructors](#rc-ctor-virtual)\n* [C.83: For value-like types, consider providing a `noexcept` swap function](#rc-swap)\n* [C.84: A `swap` must not fail](#rc-swap-fail)\n* [C.85: Make `swap` `noexcept`](#rc-swap-noexcept)\n* [C.86: Make `==` symmetric with respect of operand types and `noexcept`](#rc-eq)\n* [C.87: Beware of `==` on base classes](#rc-eq-base)\n* [C.89: Make a `hash` `noexcept`](#rc-hash)\n* [C.90: Rely on constructors and assignment operators, not memset and memcpy](#rc-memset)\n\n## <a name=\"ss-defop\"></a>C.defop: Default Operations\n\nBy default, the language supplies the default operations with their default semantics.\nHowever, a programmer can disable or replace these defaults.\n\n### <a name=\"rc-zero\"></a>C.20: If you can avoid defining default operations, do\n\n##### Reason\n\nIt's the simplest and gives the cleanest semantics.\n\n##### Example\n\n    struct Named_map {\n    public:\n        explicit Named_map(const string& n) : name(n) {}\n        // no copy/move constructors\n        // no copy/move assignment operators\n        // no destructor\n    private:\n        string name;\n        map<int, int> rep;\n    };\n\n    Named_map nm(\"map\"); // construct\n    Named_map nm2 {nm};  // copy construct\n\nSince `std::map` and `string` have all the special functions, no further work is needed.\n\n##### Note\n\nThis is known as \"the rule of zero\".\n\n##### Enforcement\n\n(Not enforceable) While not enforceable, a good static analyzer can detect patterns that indicate a possible improvement to meet this rule.\nFor example, a class with a (pointer, size) pair of members and a destructor that `delete`s the pointer could probably be converted to a `vector`.\n\n### <a name=\"rc-five\"></a>C.21: If you define or `=delete` any copy, move, or destructor function, define or `=delete` them all\n\n##### Reason\n\nThe semantics of copy, move, and destruction are closely related, so if one needs to be declared, the odds are that others need consideration too.\n\nDeclaring any copy/move/destructor function,\neven as `=default` or `=delete`, will suppress the implicit declaration\nof a move constructor and move assignment operator.\nDeclaring a move constructor or move assignment operator, even as\n`=default` or `=delete`, will cause an implicitly generated copy constructor\nor implicitly generated copy assignment operator to be defined as deleted.\nSo as soon as any of these are declared, the others should\nall be declared to avoid unwanted effects like turning all potential moves\ninto more expensive copies, or making a class move-only.\n\n##### Example, bad\n\n    struct M2 {   // bad: incomplete set of copy/move/destructor operations\n    public:\n        // ...\n        // ... no copy or move operations ...\n        ~M2() { delete[] rep; }\n    private:\n        pair<int, int>* rep;  // zero-terminated set of pairs\n    };\n\n    void use()\n    {\n        M2 x;\n        M2 y;\n        // ...\n        x = y;   // the default assignment\n        // ...\n    }\n\nGiven that \"special attention\" was needed for the destructor (here, to deallocate), the likelihood that the implicitly-defined copy and move assignment operators will be correct is low (here, we would get double deletion).\n\n##### Note\n\nThis is known as \"the rule of five.\"\n\n##### Note\n\nIf you want a default implementation (while defining another), write `=default` to show you're doing so intentionally for that function.\nIf you don't want a generated default function, suppress it with `=delete`.\n\n##### Example, good\n\nWhen a destructor needs to be declared just to make it `virtual`, it can be\ndefined as defaulted.\n\n    class AbstractBase {\n    public:\n        virtual void foo() = 0;  // at least one abstract method to make the class abstract\n        virtual ~AbstractBase() = default;\n        // ...\n    };\n\nTo prevent slicing as per [C.67](#rc-copy-virtual),\nmake the copy and move operations protected or `=delete`d, and add a `clone`:\n\n    class CloneableBase {\n    public:\n        virtual unique_ptr<CloneableBase> clone() const;\n        virtual ~CloneableBase() = default;\n        CloneableBase() = default;\n        CloneableBase(const CloneableBase&) = delete;\n        CloneableBase& operator=(const CloneableBase&) = delete;\n        CloneableBase(CloneableBase&&) = delete;\n        CloneableBase& operator=(CloneableBase&&) = delete;\n        // ... other constructors and functions ...\n    };\n\nDefining only the move operations or only the copy operations would have the\nsame effect here, but stating the intent explicitly for each special member\nmakes it more obvious to the reader.\n\n##### Note\n\nCompilers enforce much of this rule and ideally warn about any violation.\n\n##### Note\n\nRelying on an implicitly generated copy operation in a class with a destructor is deprecated.\n\n##### Note\n\nWriting these functions can be error-prone.\nNote their argument types:\n\n    class X {\n    public:\n        // ...\n        virtual ~X() = default;               // destructor (virtual if X is meant to be a base class)\n        X(const X&) = default;                // copy constructor\n        X& operator=(const X&) = default;     // copy assignment\n        X(X&&) noexcept = default;            // move constructor\n        X& operator=(X&&) noexcept = default; // move assignment\n    };\n\nA minor mistake (such as a misspelling, leaving out a `const`, using `&` instead of `&&`, or leaving out a special function) can lead to errors or warnings.\nTo avoid the tedium and the possibility of errors, try to follow the [rule of zero](#rc-zero).\n\n##### Enforcement\n\n(Simple) A class should have a declaration (even a `=delete` one) for either all or none of the copy/move/destructor functions.\n\n### <a name=\"rc-matched\"></a>C.22: Make default operations consistent\n\n##### Reason\n\nThe default operations are conceptually a matched set. Their semantics are interrelated.\nUsers will be surprised if copy/move construction and copy/move assignment do logically different things. Users will be surprised if constructors and destructors do not provide a consistent view of resource management. Users will be surprised if copy and move don't reflect the way constructors and destructors work.\n\n##### Example, bad\n\n    class Silly {   // BAD: Inconsistent copy operations\n        class Impl {\n            // ...\n        };\n        shared_ptr<Impl> p;\n    public:\n        Silly(const Silly& a) : p(make_shared<Impl>()) { *p = *a.p; }   // deep copy\n        Silly& operator=(const Silly& a) { p = a.p; return *this; }   // shallow copy\n        // ...\n    };\n\nThese operations disagree about copy semantics. This will lead to confusion and bugs.\n\n##### Enforcement\n\n* (Complex) A copy/move constructor and the corresponding copy/move assignment operator should write to the same data members at the same level of dereference.\n* (Complex) Any data members written in a copy/move constructor should also be initialized by all other constructors.\n* (Complex) If a copy/move constructor performs a deep copy of a data member, then the destructor should modify the data member.\n* (Complex) If a destructor is modifying a data member, that data member should be written in any copy/move constructors or assignment operators.\n\n## <a name=\"ss-dtor\"></a>C.dtor: Destructors\n\n\"Does this class need a destructor?\" is a surprisingly insightful design question.\nFor most classes the answer is \"no\" either because the class holds no resources or because destruction is handled by [the rule of zero](#rc-zero);\nthat is, its members can take care of themselves as concerns destruction.\nIf the answer is \"yes\", much of the design of the class follows (see [the rule of five](#rc-five)).\n\n### <a name=\"rc-dtor\"></a>C.30: Define a destructor if a class needs an explicit action at object destruction\n\n##### Reason\n\nA destructor is implicitly invoked at the end of an object's lifetime.\nIf the default destructor is sufficient, use it.\nOnly define a non-default destructor if a class needs to execute code that is not already part of its members' destructors.\n\n##### Example\n\n    template<typename A>\n    struct final_action {   // slightly simplified\n        A act;\n        final_action(A a) : act{a} {}\n        ~final_action() { act(); }\n    };\n\n    template<typename A>\n    final_action<A> finally(A act)   // deduce action type\n    {\n        return final_action<A>{act};\n    }\n\n    void test()\n    {\n        auto act = finally([] { cout << \"Exit test\\n\"; });  // establish exit action\n        // ...\n        if (something) return;   // act done here\n        // ...\n    } // act done here\n\nThe whole purpose of `final_action` is to get a piece of code (usually a lambda) executed upon destruction.\n\n##### Note\n\nThere are two general categories of classes that need a user-defined destructor:\n\n* A class with a resource that is not already represented as a class with a destructor, e.g., a `vector` or a transaction class.\n* A class that exists primarily to execute an action upon destruction, such as a tracer or `final_action`.\n\n##### Example, bad\n\n    class Foo {   // bad; use the default destructor\n    public:\n        // ...\n        ~Foo() { s = \"\"; i = 0; vi.clear(); }  // clean up\n    private:\n        string s;\n        int i;\n        vector<int> vi;\n    };\n\nThe default destructor does it better, more efficiently, and can't get it wrong.\n\n##### Enforcement\n\nLook for likely \"implicit resources\", such as pointers and references. Look for classes with destructors even though all their data members have destructors.\n\n### <a name=\"rc-dtor-release\"></a>C.31: All resources acquired by a class must be released by the class's destructor\n\n##### Reason\n\nPrevention of resource leaks, especially in error cases.\n\n##### Note\n\nFor resources represented as classes with a complete set of default operations, this happens automatically.\n\n##### Example\n\n    class X {\n        ifstream f;   // might own a file\n        // ... no default operations defined or =deleted ...\n    };\n\n`X`'s `ifstream` implicitly closes any file it might have open upon destruction of its `X`.\n\n##### Example, bad\n\n    class X2 {     // bad\n        FILE* f;   // might own a file\n        // ... no default operations defined or =deleted ...\n    };\n\n`X2` might leak a file handle.\n\n##### Note\n\nWhat about a socket that won't close? A destructor, close, or cleanup operation [should never fail](#rc-dtor-fail).\nIf it does nevertheless, we have a problem that has no really good solution.\nFor starters, the writer of a destructor does not know why the destructor is called and cannot \"refuse to act\" by throwing an exception.\nSee [discussion](#sd-never-fail).\nTo make the problem worse, many \"close/release\" operations are not retryable.\nMany have tried to solve this problem, but no general solution is known.\nIf at all possible, consider failure to close/clean up a fundamental design error and terminate.\n\n##### Note\n\nA class can hold pointers and references to objects that it does not own.\nObviously, such objects should not be `delete`d by the class's destructor.\nFor example:\n\n    Preprocessor pp { /* ... */ };\n    Parser p { pp, /* ... */ };\n    Type_checker tc { p, /* ... */ };\n\nHere `p` refers to `pp` but does not own it.\n\n##### Enforcement\n\n* (Simple) If a class has pointer or reference members that are owners\n  (e.g., deemed owners by using `gsl::owner`), then they should be referenced in its destructor.\n* (Hard) Determine if pointer or reference members are owners when there is no explicit statement of ownership\n  (e.g., look into the constructors).\n\n### <a name=\"rc-dtor-ptr\"></a>C.32: If a class has a raw pointer (`T*`) or reference (`T&`), consider whether it might be owning\n\n##### Reason\n\nThere is a lot of code that is non-specific about ownership.\n\n##### Example\n\n    class legacy_class\n    {\n        foo* m_owning;   // Bad: change to unique_ptr<T> or owner<T*>\n        bar* m_observer; // OK: keep\n    }\n\nThe only way to determine ownership may be code analysis.\n\n##### Note\n\nOwnership should be clear in new code (and refactored legacy code) according to [R.20](#rr-owner) for owning\npointers and [R.3](#rr-ptr) for non-owning pointers.  References should never own [R.4](#rr-ref).\n\n##### Enforcement\n\nLook at the initialization of raw member pointers and member references and see if an allocation is used.\n\n### <a name=\"rc-dtor-ptr2\"></a>C.33: If a class has an owning pointer member, define a destructor\n\n##### Reason\n\nAn owned object must be `delete`d upon destruction of the object that owns it.\n\n##### Example\n\nA pointer member could represent a resource.\n[A `T*` should not do so](#rr-ptr), but in older code, that's common.\nConsider a `T*` a possible owner and therefore suspect.\n\n    template<typename T>\n    class Smart_ptr {\n        T* p;   // BAD: vague about ownership of *p\n        // ...\n    public:\n        // ... no user-defined default operations ...\n    };\n\n    void use(Smart_ptr<int> p1)\n    {\n        // error: p2.p leaked (if not nullptr and not owned by some other code)\n        auto p2 = p1;\n    }\n\nNote that if you define a destructor, you must define or delete [all default operations](#rc-five):\n\n    template<typename T>\n    class Smart_ptr2 {\n        T* p;   // BAD: vague about ownership of *p\n        // ...\n    public:\n        // ... no user-defined copy operations ...\n        ~Smart_ptr2() { delete p; }  // p is an owner!\n    };\n\n    void use(Smart_ptr2<int> p1)\n    {\n        auto p2 = p1;   // error: double deletion\n    }\n\nThe default copy operation will just copy the `p1.p` into `p2.p` leading to a double destruction of `p1.p`. Be explicit about ownership:\n\n    template<typename T>\n    class Smart_ptr3 {\n        owner<T*> p;   // OK: explicit about ownership of *p\n        // ...\n    public:\n        // ...\n        // ... copy and move operations ...\n        ~Smart_ptr3() { delete p; }\n    };\n\n    void use(Smart_ptr3<int> p1)\n    {\n        auto p2 = p1;   // OK: no double deletion\n    }\n\n##### Note\n\nOften the simplest way to get a destructor is to replace the pointer with a smart pointer (e.g., `std::unique_ptr`) and let the compiler arrange for proper destruction to be done implicitly.\n\n##### Note\n\nWhy not just require all owning pointers to be \"smart pointers\"?\nThat would sometimes require non-trivial code changes and might affect ABIs.\n\n##### Enforcement\n\n* A class with a pointer data member is suspect.\n* A class with an `owner<T>` should define its default operations.\n\n\n### <a name=\"rc-dtor-virtual\"></a>C.35: A base class destructor should be either public and virtual, or protected and non-virtual\n\n##### Reason\n\nTo prevent undefined behavior.\nIf the destructor is public, then calling code can attempt to destroy a derived class object through a base class pointer, and the result is undefined if the base class's destructor is non-virtual.\nIf the destructor is protected, then calling code cannot destroy through a base class pointer and the destructor does not need to be virtual; it does need to be protected, not private, so that derived destructors can invoke it.\nIn general, the writer of a base class does not know the appropriate action to be done upon destruction.\n\n##### Discussion\n\nSee [this in the Discussion section](#sd-dtor).\n\n##### Example, bad\n\n    struct Base {  // BAD: implicitly has a public non-virtual destructor\n        virtual void f();\n    };\n\n    struct D : Base {\n        string s {\"a resource needing cleanup\"};\n        ~D() { /* ... do some cleanup ... */ }\n        // ...\n    };\n\n    void use()\n    {\n        unique_ptr<Base> p = make_unique<D>();\n        // ...\n    } // p's destruction calls ~Base(), not ~D(), which leaks D::s and possibly more\n\n##### Note\n\nA virtual function defines an interface to derived classes that can be used without looking at the derived classes.\nIf the interface allows destroying, it should be safe to do so.\n\n##### Note\n\nA destructor must be non-private or it will prevent using the type:\n\n    class X {\n        ~X();   // private destructor\n        // ...\n    };\n\n    void use()\n    {\n        X a;                        // error: cannot destroy\n        auto p = make_unique<X>();  // error: cannot destroy\n    }\n\n##### Exception\n\nWe can imagine one case where you could want a protected virtual destructor: When an object of a derived type (and only of such a type) should be allowed to destroy *another* object (not itself) through a pointer to base. We haven't seen such a case in practice, though.\n\n\n##### Enforcement\n\n* A class with any virtual functions should have a destructor that is either public and virtual or else protected and non-virtual.\n* If a class inherits publicly from a base class, the base class should have a destructor that is either public and virtual or else protected and non-virtual.\n\n### <a name=\"rc-dtor-fail\"></a>C.36: A destructor must not fail\n\n##### Reason\n\nIn general we do not know how to write error-free code if a destructor should fail.\nThe standard library requires that all classes it deals with have destructors that do not exit by throwing.\n\n##### Example\n\n    class X {\n    public:\n        ~X() noexcept;\n        // ...\n    };\n\n    X::~X() noexcept\n    {\n        // ...\n        if (cannot_release_a_resource) terminate();\n        // ...\n    }\n\n##### Note\n\nMany have tried to devise a fool-proof scheme for dealing with failure in destructors.\nNone have succeeded to come up with a general scheme.\nThis can be a real practical problem: For example, what about a socket that won't close?\nThe writer of a destructor does not know why the destructor is called and cannot \"refuse to act\" by throwing an exception.\nSee [discussion](#sd-never-fail).\nTo make the problem worse, many \"close/release\" operations are not retryable.\nIf at all possible, consider failure to close/clean up a fundamental design error and terminate.\n\n##### Note\n\nDeclare a destructor `noexcept`. That will ensure that it either completes normally or terminates the program.\n\n##### Note\n\nIf a resource cannot be released and the program must not fail, try to signal the failure to the rest of the system somehow\n(maybe even by modifying some global state and hope something will notice and be able to take care of the problem).\nBe fully aware that this technique is special-purpose and error-prone.\nConsider the \"my connection will not close\" example.\nProbably there is a problem at the other end of the connection and only a piece of code responsible for both ends of the connection can properly handle the problem.\nThe destructor could send a message (somehow) to the responsible part of the system, consider that to have closed the connection, and return normally.\n\n##### Note\n\nIf a destructor uses operations that could fail, it can catch exceptions and in some cases still complete successfully\n(e.g., by using a different clean-up mechanism from the one that threw an exception).\n\n##### Enforcement\n\n(Simple) A destructor should be declared `noexcept` if it could throw.\n\n### <a name=\"rc-dtor-noexcept\"></a>C.37: Make destructors `noexcept`\n\n##### Reason\n\n [A destructor must not fail](#rc-dtor-fail). If a destructor tries to exit with an exception, it's a bad design error and the program had better terminate.\n\n##### Note\n\nA destructor (either user-defined or compiler-generated) is implicitly declared `noexcept` (independently of what code is in its body) if all of the members of its class have `noexcept` destructors. By explicitly marking destructors `noexcept`, an author guards against the destructor becoming implicitly `noexcept(false)` through the addition or modification of a class member.\n\n##### Example\n\nNot all destructors are noexcept by default; one throwing member poisons the whole class hierarchy\n\n    struct X {\n        Details x;  // happens to have a throwing destructor\n        // ...\n        ~X() { }    // implicitly noexcept(false); aka can throw\n    };\n\nSo, if in doubt, declare a destructor noexcept.\n\n##### Note\n\nWhy not then declare all destructors noexcept?\nBecause that would in many cases -- especially simple cases -- be distracting clutter.\n\n##### Enforcement\n\n(Simple) A destructor should be declared `noexcept` if it could throw.\n\n## <a name=\"ss-ctor\"></a>C.ctor: Constructors\n\nA constructor defines how an object is initialized (constructed).\n\n### <a name=\"rc-ctor\"></a>C.40: Define a constructor if a class has an invariant\n\n##### Reason\n\nThat's what constructors are for.\n\n##### Example\n\n    class Date {  // a Date represents a valid date\n                  // in the January 1, 1900 to December 31, 2100 range\n        Date(int dd, int mm, int yy)\n            :d{dd}, m{mm}, y{yy}\n        {\n            if (!is_valid(d, m, y)) throw Bad_date{};  // enforce invariant\n        }\n        // ...\n    private:\n        int d, m, y;\n    };\n\nIt is often a good idea to express the invariant as an `Ensures` on the constructor.\n\n##### Note\n\nA constructor can be used for convenience even if a class does not have an invariant. For example:\n\n    struct Rec {\n        string s;\n        int i {0};\n        Rec(const string& ss) : s{ss} {}\n        Rec(int ii) :i{ii} {}\n    };\n\n    Rec r1 {7};\n    Rec r2 {\"Foo bar\"};\n\n##### Note\n\nThe C++11 initializer list rule eliminates the need for many constructors. For example:\n\n    struct Rec2{\n        string s;\n        int i;\n        Rec2(const string& ss, int ii = 0) :s{ss}, i{ii} {}   // redundant\n    };\n\n    Rec2 r1 {\"Foo\", 7};\n    Rec2 r2 {\"Bar\"};\n\nThe `Rec2` constructor is redundant.\nAlso, the default for `int` would be better done as a [default member initializer](#rc-in-class-initializer).\n\n**See also**: [construct valid object](#rc-complete) and [constructor throws](#rc-throw).\n\n##### Enforcement\n\n* Flag classes with user-defined copy operations but no constructor (a user-defined copy is a good indicator that the class has an invariant)\n\n### <a name=\"rc-complete\"></a>C.41: A constructor should create a fully initialized object\n\n##### Reason\n\nA constructor establishes the invariant for a class. A user of a class should be able to assume that a constructed object is usable.\n\n##### Example, bad\n\n    class X1 {\n        FILE* f;   // call init() before any other function\n        // ...\n    public:\n        X1() {}\n        void init();   // initialize f\n        void read();   // read from f\n        // ...\n    };\n\n    void f()\n    {\n        X1 file;\n        file.read();   // crash or bad read!\n        // ...\n        file.init();   // too late\n        // ...\n    }\n\nCompilers do not read comments.\n\n##### Exception\n\nIf a valid object cannot conveniently be constructed by a constructor, [use a factory function](#rc-factory).\n\n##### Enforcement\n\n* (Simple) Every constructor should initialize every data member (either explicitly, via a delegating ctor call or via default construction).\n* (Unknown) If a constructor has an `Ensures` contract, try to see if it holds as a postcondition.\n\n##### Note\n\nIf a constructor acquires a resource (to create a valid object), that resource should be [released by the destructor](#rc-dtor-release).\nThe idiom of having constructors acquire resources and destructors release them is called [RAII](#rr-raii) (\"Resource Acquisition Is Initialization\").\n\n### <a name=\"rc-throw\"></a>C.42: If a constructor cannot construct a valid object, throw an exception\n\n##### Reason\n\nLeaving behind an invalid object is asking for trouble.\n\n##### Example\n\n    class X2 {\n        FILE* f;\n        // ...\n    public:\n        X2(const string& name)\n            :f{fopen(name.c_str(), \"r\")}\n        {\n            if (!f) throw runtime_error{\"could not open\" + name};\n            // ...\n        }\n\n        void read();      // read from f\n        // ...\n    };\n\n    void f()\n    {\n        X2 file {\"Zeno\"}; // throws if file isn't open\n        file.read();      // fine\n        // ...\n    }\n\n##### Example, bad\n\n    class X3 {     // bad: the constructor leaves a non-valid object behind\n        FILE* f;   // call is_valid() before any other function\n        bool valid;\n        // ...\n    public:\n        X3(const string& name)\n            :f{fopen(name.c_str(), \"r\")}, valid{false}\n        {\n            if (f) valid = true;\n            // ...\n        }\n\n        bool is_valid() { return valid; }\n        void read();   // read from f\n        // ...\n    };\n\n    void f()\n    {\n        X3 file {\"Heraclides\"};\n        file.read();   // crash or bad read!\n        // ...\n        if (file.is_valid()) {\n            file.read();\n            // ...\n        }\n        else {\n            // ... handle error ...\n        }\n        // ...\n    }\n\n##### Note\n\nFor a variable definition (e.g., on the stack or as a member of another object) there is no explicit function call from which an error code could be returned.\nLeaving behind an invalid object and relying on users to consistently check an `is_valid()` function before use is tedious, error-prone, and inefficient.\n\n##### Exception\n\nThere are domains, such as some hard-real-time systems (think airplane controls) where (without additional tool support) exception handling is not sufficiently predictable from a timing perspective.\nThere the `is_valid()` technique must be used. In such cases, check `is_valid()` consistently and immediately to simulate [RAII](#rr-raii).\n\n##### Alternative\n\nIf you feel tempted to use some \"post-constructor initialization\" or \"two-stage initialization\" idiom, try not to do that.\nIf you really have to, look at [factory functions](#rc-factory).\n\n##### Note\n\nOne reason people have used `init()` functions rather than doing the initialization work in a constructor has been to avoid code replication.\n[Delegating constructors](#rc-delegating) and [default member initialization](#rc-in-class-initializer) do that better.\nAnother reason has been to delay initialization until an object is needed; the solution to that is often [not to declare a variable until it can be properly initialized](#res-init).\n\n##### Enforcement\n\n???\n\n### <a name=\"rc-default0\"></a>C.43: Ensure that a copyable class has a default constructor\n\n##### Reason\n\nThat is, ensure that if a concrete class is copyable it also satisfies the rest of \"semiregular.\"\n\nMany language and library facilities rely on default constructors to initialize their elements, e.g. `T a[10]` and `std::vector<T> v(10)`.\nA default constructor often simplifies the task of defining a suitable [moved-from state](#???) for a type that is also copyable.\n\n##### Example\n\n    class Date { // BAD: no default constructor\n    public:\n        Date(int dd, int mm, int yyyy);\n        // ...\n    };\n\n    vector<Date> vd1(1000);   // default Date needed here\n    vector<Date> vd2(1000, Date{7, Month::October, 1885});   // alternative\n\nThe default constructor is only auto-generated if there is no user-declared constructor, hence it's impossible to initialize the vector `vd1` in the example above.\nThe absence of a default value can cause surprises for users and complicate its use, so if one can be reasonably defined, it should be.\n\n`Date` is chosen to encourage thought:\nThere is no \"natural\" default date (the big bang is too far back in time to be useful for most people), so this example is non-trivial.\n`{0, 0, 0}` is not a valid date in most calendar systems, so choosing that would be introducing something like floating-point's `NaN`.\nHowever, most realistic `Date` classes have a \"first date\" (e.g. January 1, 1970 is popular), so making that the default is usually trivial.\n\n    class Date {\n    public:\n        Date(int dd, int mm, int yyyy);\n        Date() = default; // [See also](#rc-default)\n        // ...\n    private:\n        int dd {1};\n        int mm {1};\n        int yyyy {1970};\n        // ...\n    };\n\n    vector<Date> vd1(1000);\n\n##### Note\n\nA class with members that all have default constructors implicitly gets a default constructor:\n\n    struct X {\n        string s;\n        vector<int> v;\n    };\n\n    X x; // means X{ { }, { } }; that is the empty string and the empty vector\n\nBeware that built-in types are not properly default constructed:\n\n    struct X {\n        string s;\n        int i;\n    };\n\n    void f()\n    {\n        X x;    // x.s is initialized to the empty string; x.i is uninitialized\n\n        cout << x.s << ' ' << x.i << '\\n';\n        ++x.i;\n    }\n\nStatically allocated objects of built-in types are by default initialized to `0`, but local built-in variables are not.\nBeware that your compiler might default initialize local built-in variables, whereas an optimized build will not.\nThus, code like the example above might appear to work, but it relies on undefined behavior.\nAssuming that you want initialization, an explicit default initialization can help:\n\n    struct X {\n        string s;\n        int i {};   // default initialize (to 0)\n    };\n\n##### Notes\n\nClasses that don't have a reasonable default construction are usually not copyable either, so they don't fall under this guideline.\n\nFor example, a base class should not be copyable, and so does not necessarily need a default constructor:\n\n    // Shape is an abstract base class, not a copyable type.\n    // It might or might not need a default constructor.\n    struct Shape {\n        virtual void draw() = 0;\n        virtual void rotate(int) = 0;\n        // =delete copy/move functions\n        // ...\n    };\n\nA class that must acquire a caller-provided resource during construction often cannot have a default constructor, but it does not fall under this guideline because such a class is usually not copyable anyway:\n\n    // std::lock_guard is not a copyable type.\n    // It does not have a default constructor.\n    lock_guard g {mx};  // guard the mutex mx\n    lock_guard g2;      // error: guarding nothing\n\nA class that has a \"special state\" that must be handled separately from other states by member functions or users causes extra work\n(and most likely more errors). Such a type can naturally use the special state as a default constructed value, whether or not it is copyable:\n\n    // std::ofstream is not a copyable type.\n    // It does happen to have a default constructor\n    // that goes along with a special \"not open\" state.\n    ofstream out {\"Foobar\"};\n    // ...\n    out << log(time, transaction);\n\nSimilar special-state types that are copyable, such as copyable smart pointers that have the special state \"==nullptr\", should use the special state as their default constructed value.\n\nHowever, it is preferable to have a default constructor default to a meaningful state such as `std::string`s `\"\"` and `std::vector`s `{}`.\n\n##### Enforcement\n\n* Flag classes that are copyable by `=` without a default constructor\n* Flag classes that are comparable with `==` but not copyable\n\n\n### <a name=\"rc-default00\"></a>C.44: Prefer default constructors to be simple and non-throwing\n\n##### Reason\n\nBeing able to set a value to \"the default\" without operations that might fail simplifies error handling and reasoning about move operations.\n\n##### Example, problematic\n\n    template<typename T>\n    // elem points to space-elem element allocated using new\n    class Vector0 {\n    public:\n        Vector0() :Vector0{0} {}\n        Vector0(int n) :elem{new T[n]}, space{elem + n}, last{elem} {}\n        // ...\n    private:\n        own<T*> elem;\n        T* space;\n        T* last;\n    };\n\nThis is nice and general, but setting a `Vector0` to empty after an error involves an allocation, which might fail.\nAlso, having a default `Vector` represented as `{new T[0], 0, 0}` seems wasteful.\nFor example, `Vector0<int> v[100]` costs 100 allocations.\n\n##### Example\n\n    template<typename T>\n    // elem is nullptr or elem points to space-elem element allocated using new\n    class Vector1 {\n    public:\n        // sets the representation to {nullptr, nullptr, nullptr}; doesn't throw\n        Vector1() noexcept {}\n        Vector1(int n) :elem{new T[n]}, space{elem + n}, last{elem} {}\n        // ...\n    private:\n        own<T*> elem {};\n        T* space {};\n        T* last {};\n    };\n\nUsing `{nullptr, nullptr, nullptr}` makes `Vector1{}` cheap, but a special case and implies run-time checks.\nSetting a `Vector1` to empty after detecting an error is trivial.\n\n##### Enforcement\n\n* Flag throwing default constructors\n\n### <a name=\"rc-default\"></a>C.45: Don't define a default constructor that only initializes data members; use default member initializers instead\n\n##### Reason\n\nUsing default member initializers lets the compiler generate the function for you. The compiler-generated function can be more efficient.\n\n##### Example, bad\n\n    class X1 { // BAD: doesn't use member initializers\n        string s;\n        int i;\n    public:\n        X1() :s{\"default\"}, i{1} { }\n        // ...\n    };\n\n##### Example\n\n    class X2 {\n        string s {\"default\"};\n        int i {1};\n    public:\n        // use compiler-generated default constructor\n        // ...\n    };\n\n##### Enforcement\n\n(Simple) Flag if a default constructor's explicit member initializer is a constant, and recommend that the constant should be written as a data member initializer instead.\n\n### <a name=\"rc-explicit\"></a>C.46: By default, declare single-argument constructors explicit\n\n##### Reason\n\nTo avoid unintended conversions.\n\n##### Example, bad\n\n    class String {\n    public:\n        String(int);   // BAD\n        // ...\n    };\n\n    String s = 10;   // surprise: string of size 10\n\n##### Exception\n\nIf you really want an implicit conversion from the constructor argument type to the class type, don't use `explicit`:\n\n    class Complex {\n    public:\n        Complex(double d);   // OK: we want a conversion from d to {d, 0}\n        // ...\n    };\n\n    Complex z = 10.7;   // unsurprising conversion\n\n**See also**: [Discussion of implicit conversions](#ro-conversion)\n\n##### Note\n\nCopy and move constructors should not be made `explicit` because they do not perform conversions. Explicit copy/move constructors make passing and returning by value difficult.\n\n##### Enforcement\n\n(Simple) Single-argument constructors should be declared `explicit`. Good single argument non-`explicit` constructors are rare in most code bases. Warn for all that are not on a \"positive list\".\n\n### <a name=\"rc-order\"></a>C.47: Define and initialize data members in the order of member declaration\n\n##### Reason\n\nTo minimize confusion and errors. That is the order in which the initialization happens (independent of the order of member initializers).\n\n##### Example, bad\n\n    class Foo {\n        int m1;\n        int m2;\n    public:\n        Foo(int x) :m2{x}, m1{++x} { }   // BAD: misleading initializer order\n        // ...\n    };\n\n    Foo x(1); // surprise: x.m1 == x.m2 == 2\n\n##### Enforcement\n\n(Simple) A member initializer list should mention the members in the same order they are declared.\n\n**See also**: [Discussion](#sd-order)\n\n### <a name=\"rc-in-class-initializer\"></a>C.48: Prefer default member initializers to member initializers in constructors for constant initializers\n\n##### Reason\n\nMakes it explicit that the same value is expected to be used in all constructors. Avoids repetition. Avoids maintenance problems. It leads to the shortest and most efficient code.\n\n##### Example, bad\n\n    class X {   // BAD\n        int i;\n        string s;\n        int j;\n    public:\n        X() :i{666}, s{\"qqq\"} { }   // j is uninitialized\n        X(int ii) :i{ii} {}         // s is \"\" and j is uninitialized\n        // ...\n    };\n\nHow would a maintainer know whether `j` was deliberately uninitialized (probably a bad idea anyway) and whether it was intentional to give `s` the default value `\"\"` in one case and `qqq` in another (almost certainly a bug)? The problem with `j` (forgetting to initialize a member) often happens when a new member is added to an existing class.\n\n##### Example\n\n    class X2 {\n        int i {666};\n        string s {\"qqq\"};\n        int j {0};\n    public:\n        X2() = default;        // all members are initialized to their defaults\n        X2(int ii) :i{ii} {}   // s and j initialized to their defaults\n        // ...\n    };\n\n**Alternative**: We can get part of the benefits from default arguments to constructors, and that is not uncommon in older code. However, that is less explicit, causes more arguments to be passed, and is repetitive when there is more than one constructor:\n\n    class X3 {   // BAD: inexplicit, argument passing overhead\n        int i;\n        string s;\n        int j;\n    public:\n        X3(int ii = 666, const string& ss = \"qqq\", int jj = 0)\n            :i{ii}, s{ss}, j{jj} { }   // all members are initialized to their defaults\n        // ...\n    };\n\n##### Enforcement\n\n* (Simple) Every constructor should initialize every data member (either explicitly, via a delegating ctor call or via default construction).\n* (Simple) Default arguments to constructors suggest a default member initializer might be more appropriate.\n\n### <a name=\"rc-initialize\"></a>C.49: Prefer initialization to assignment in constructors\n\n##### Reason\n\nAn initialization explicitly states that initialization, rather than assignment, is done and can be more elegant and efficient. Prevents \"use before set\" errors.\n\n##### Example, good\n\n    class A {   // Good\n        string s1;\n    public:\n        A(czstring p) : s1{p} { }    // GOOD: directly construct (and the C-string is explicitly named)\n        // ...\n    };\n\n##### Example, bad\n\n    class B {   // BAD\n        string s1;\n    public:\n        B(const char* p) { s1 = p; }   // BAD: default constructor followed by assignment\n        // ...\n    };\n\n    class C {   // UGLY, aka very bad\n        int* p;\n    public:\n        C() { cout << *p; p = new int{10}; }   // accidental use before initialized\n        // ...\n    };\n\n##### Example, better still\n\nInstead of those `const char*`s we could use C++17 `std::string_view` or `gsl::span<char>`\nas [a more general way to present arguments to a function](#rstr-view):\n\n    class D {   // Good\n        string s1;\n    public:\n        D(string_view v) : s1{v} { }    // GOOD: directly construct\n        // ...\n    };\n\n### <a name=\"rc-factory\"></a>C.50: Use a factory function if you need \"virtual behavior\" during initialization\n\n##### Reason\n\nIf the state of a base class object must depend on the state of a derived part of the object, we need to use a virtual function (or equivalent) while minimizing the window of opportunity to misuse an imperfectly constructed object.\n\n##### Note\n\nThe return type of the factory should normally be `unique_ptr` by default; if some uses are shared, the caller can `move` the `unique_ptr` into a `shared_ptr`. However, if the factory author knows that all uses of the returned object will be shared uses, return `shared_ptr` and use `make_shared` in the body to save an allocation.\n\n##### Example, bad\n\n    class B {\n    public:\n        B()\n        {\n            /* ... */\n            f(); // BAD: C.82: Don't call virtual functions in constructors and destructors\n            /* ... */\n        }\n\n        virtual void f() = 0;\n    };\n\n##### Example\n\n    class B {\n    protected:\n        class Token {};\n\n    public:\n        explicit B(Token) { /* ... */ }  // create an imperfectly initialized object\n        virtual void f() = 0;\n\n        template<class T>\n        static shared_ptr<T> create()    // interface for creating shared objects\n        {\n            auto p = make_shared<T>(typename T::Token{});\n            p->post_initialize();\n            return p;\n        }\n\n    protected:\n        virtual void post_initialize()   // called right after construction\n            { /* ... */ f(); /* ... */ } // GOOD: virtual dispatch is safe\n    };\n\n    class D : public B {                 // some derived class\n    protected:\n        class Token {};\n\n    public:\n        explicit D(Token) : B{ B::Token{} } {}\n        void f() override { /* ...  */ };\n\n    protected:\n        template<class T>\n        friend shared_ptr<T> B::create();\n    };\n\n    shared_ptr<D> p = D::create<D>();  // creating a D object\n\n`make_shared` requires that the constructor is public. By requiring a protected `Token` the constructor cannot be publicly called anymore, so we avoid an incompletely constructed object escaping into the wild.\nBy providing the factory function `create()`, we make construction (on the free store) convenient.\n\n##### Note\n\nConventional factory functions allocate on the free store, rather than on the stack or in an enclosing object.\n\n**See also**: [Discussion](#sd-factory)\n\n### <a name=\"rc-delegating\"></a>C.51: Use delegating constructors to represent common actions for all constructors of a class\n\n##### Reason\n\nTo avoid repetition and accidental differences.\n\n##### Example, bad\n\n    class Date {   // BAD: repetitive\n        int d;\n        Month m;\n        int y;\n    public:\n        Date(int dd, Month mm, year yy)\n            :d{dd}, m{mm}, y{yy}\n            { if (!valid(d, m, y)) throw Bad_date{}; }\n\n        Date(int dd, Month mm)\n            :d{dd}, m{mm} y{current_year()}\n            { if (!valid(d, m, y)) throw Bad_date{}; }\n        // ...\n    };\n\nThe common action gets tedious to write and might accidentally not be common.\n\n##### Example\n\n    class Date2 {\n        int d;\n        Month m;\n        int y;\n    public:\n        Date2(int dd, Month mm, year yy)\n            :d{dd}, m{mm}, y{yy}\n            { if (!valid(d, m, y)) throw Bad_date{}; }\n\n        Date2(int dd, Month mm)\n            :Date2{dd, mm, current_year()} {}\n        // ...\n    };\n\n**See also**: If the \"repeated action\" is a simple initialization, consider [a default member initializer](#rc-in-class-initializer).\n\n##### Enforcement\n\n(Moderate) Look for similar constructor bodies.\n\n### <a name=\"rc-inheriting\"></a>C.52: Use inheriting constructors to import constructors into a derived class that does not need further explicit initialization\n\n##### Reason\n\nIf you need those constructors for a derived class, re-implementing them is tedious and error-prone.\n\n##### Example\n\n`std::vector` has a lot of tricky constructors, so if I want my own `vector`, I don't want to reimplement them:\n\n    class Rec {\n        // ... data and lots of nice constructors ...\n    };\n\n    class Oper : public Rec {\n        using Rec::Rec;\n        // ... no data members ...\n        // ... lots of nice utility functions ...\n    };\n\n##### Example, bad\n\n    struct Rec2 : public Rec {\n        int x;\n        using Rec::Rec;\n    };\n\n    Rec2 r {\"foo\", 7};\n    int val = r.x;   // uninitialized\n\n##### Enforcement\n\nMake sure that every member of the derived class is initialized.\n\n## <a name=\"ss-copy\"></a>C.copy: Copy and move\n\nConcrete types should generally be copyable, but interfaces in a class hierarchy should not.\nResource handles might or might not be copyable.\nTypes can be defined to move for logical as well as performance reasons.\n\n### <a name=\"rc-copy-assignment\"></a>C.60: Make copy assignment non-`virtual`, take the parameter by `const&`, and return by non-`const&`\n\n##### Reason\n\nIt is simple and efficient. If you want to optimize for rvalues, provide an overload that takes an `&&` (see [F.18](#rf-consume)).\n\n##### Example\n\n    class Foo {\n    public:\n        Foo& operator=(const Foo& x)\n        {\n            // GOOD: no need to check for self-assignment (other than performance)\n            auto tmp = x;\n            swap(tmp); // see C.83\n            return *this;\n        }\n        // ...\n    };\n\n    Foo a;\n    Foo b;\n    Foo f();\n\n    a = b;    // assign lvalue: copy\n    a = f();  // assign rvalue: potentially move\n\n##### Note\n\nThe `swap` implementation technique offers the [strong guarantee](#Abrahams01).\n\n##### Example\n\nBut what if you can get significantly better performance by not making a temporary copy? Consider a simple `Vector` intended for a domain where assignment of large, equal-sized `Vector`s is common. In this case, the copy of elements implied by the `swap` implementation technique could cause an order of magnitude increase in cost:\n\n    template<typename T>\n    class Vector {\n    public:\n        Vector& operator=(const Vector&);\n        // ...\n    private:\n        T* elem;\n        int sz;\n    };\n\n    Vector& Vector::operator=(const Vector& a)\n    {\n        if (a.sz > sz) {\n            // ... use the swap technique, it can't be bettered ...\n            return *this;\n        }\n        // ... copy sz elements from *a.elem to elem ...\n        if (a.sz < sz) {\n            // ... destroy the surplus elements in *this and adjust size ...\n        }\n        return *this;\n    }\n\nBy writing directly to the target elements, we will get only [the basic guarantee](#Abrahams01) rather than the strong guarantee offered by the `swap` technique. Beware of [self-assignment](#rc-copy-self).\n\n**Alternatives**: If you think you need a `virtual` assignment operator, and understand why that's deeply problematic, don't call it `operator=`. Make it a named function like `virtual void assign(const Foo&)`.\nSee [copy constructor vs. `clone()`](#rc-copy-virtual).\n\n##### Enforcement\n\n* (Simple) An assignment operator should not be virtual. Here be dragons!\n* (Simple) An assignment operator should return `T&` to enable chaining, not alternatives like `const T&` which interfere with composability and putting objects in containers.\n* (Moderate) An assignment operator should (implicitly or explicitly) invoke all base and member assignment operators.\n  Look at the destructor to determine if the type has pointer semantics or value semantics.\n\n### <a name=\"rc-copy-semantic\"></a>C.61: A copy operation should copy\n\n##### Reason\n\nThat is the generally assumed semantics. After `x = y`, we should have `x == y`.\nAfter a copy `x` and `y` can be independent objects (value semantics, the way non-pointer built-in types and the standard-library types work) or refer to a shared object (pointer semantics, the way pointers work).\n\n##### Example\n\n    class X {   // OK: value semantics\n    public:\n        X();\n        X(const X&);     // copy X\n        void modify();   // change the value of X\n        // ...\n        ~X() { delete[] p; }\n    private:\n        T* p;\n        int sz;\n    };\n\n    bool operator==(const X& a, const X& b)\n    {\n        return a.sz == b.sz && equal(a.p, a.p + a.sz, b.p, b.p + b.sz);\n    }\n\n    X::X(const X& a)\n        :p{new T[a.sz]}, sz{a.sz}\n    {\n        copy(a.p, a.p + sz, p);\n    }\n\n    X x;\n    X y = x;\n    if (x != y) throw Bad{};\n    x.modify();\n    if (x == y) throw Bad{};   // assume value semantics\n\n##### Example\n\n    class X2 {  // OK: pointer semantics\n    public:\n        X2();\n        X2(const X2&) = default; // shallow copy\n        ~X2() = default;\n        void modify();          // change the pointed-to value\n        // ...\n    private:\n        T* p;\n        int sz;\n    };\n\n    bool operator==(const X2& a, const X2& b)\n    {\n        return a.sz == b.sz && a.p == b.p;\n    }\n\n    X2 x;\n    X2 y = x;\n    if (x != y) throw Bad{};\n    x.modify();\n    if (x != y) throw Bad{};  // assume pointer semantics\n\n##### Note\n\nPrefer value semantics unless you are building a \"smart pointer\". Value semantics is the simplest to reason about and what the standard-library facilities expect.\n\n##### Enforcement\n\n(Not enforceable)\n\n### <a name=\"rc-copy-self\"></a>C.62: Make copy assignment safe for self-assignment\n\n##### Reason\n\nIf `x = x` changes the value of `x`, people will be surprised and bad errors will occur (often including leaks).\n\n##### Example\n\nThe standard-library containers handle self-assignment elegantly and efficiently:\n\n    std::vector<int> v = {3, 1, 4, 1, 5, 9};\n    v = v;\n    // the value of v is still {3, 1, 4, 1, 5, 9}\n\n##### Note\n\nThe default assignment generated from members that handle self-assignment correctly handles self-assignment.\n\n    struct Bar {\n        vector<pair<int, int>> v;\n        map<string, int> m;\n        string s;\n    };\n\n    Bar b;\n    // ...\n    b = b;   // correct and efficient\n\n##### Note\n\nYou can handle self-assignment by explicitly testing for self-assignment, but often it is faster and more elegant to cope without such a test (e.g., [using `swap`](#rc-swap)).\n\n    class Foo {\n        string s;\n        int i;\n    public:\n        Foo& operator=(const Foo& a);\n        // ...\n    };\n\n    Foo& Foo::operator=(const Foo& a)   // OK, but there is a cost\n    {\n        if (this == &a) return *this;\n        s = a.s;\n        i = a.i;\n        return *this;\n    }\n\nThis is obviously safe and apparently efficient.\nHowever, what if we do one self-assignment per million assignments?\nThat's about a million redundant tests (but since the answer is essentially always the same, the computer's branch predictor will guess right essentially every time).\nConsider:\n\n    Foo& Foo::operator=(const Foo& a)   // simpler, and probably much better\n    {\n        s = a.s;\n        i = a.i;\n        return *this;\n    }\n\n`std::string` is safe for self-assignment and so are `int`. All the cost is carried by the (rare) case of self-assignment.\n\n##### Enforcement\n\n(Simple) Assignment operators should not contain the pattern `if (this == &a) return *this;` ???\n\n### <a name=\"rc-move-assignment\"></a>C.63: Make move assignment non-`virtual`, take the parameter by `&&`, and return by non-`const&`\n\n##### Reason\n\nIt is simple and efficient.\n\n**See**: [The rule for copy-assignment](#rc-copy-assignment).\n\n##### Enforcement\n\nEquivalent to what is done for [copy-assignment](#rc-copy-assignment).\n\n* (Simple) An assignment operator should not be virtual. Here be dragons!\n* (Simple) An assignment operator should return `T&` to enable chaining, not alternatives like `const T&` which interfere with composability and putting objects in containers.\n* (Moderate) A move assignment operator should (implicitly or explicitly) invoke all base and member move assignment operators.\n\n### <a name=\"rc-move-semantic\"></a>C.64: A move operation should move and leave its source in a valid state\n\n##### Reason\n\nThat is the generally assumed semantics.\nAfter `y = std::move(x)` the value of `y` should be the value `x` had and `x` should be in a valid state.\n\n##### Example\n\n    class X {   // OK: value semantics\n    public:\n        X();\n        X(X&& a) noexcept;  // move X\n        X& operator=(X&& a) noexcept; // move-assign X\n        void modify();     // change the value of X\n        // ...\n        ~X() { delete[] p; }\n    private:\n        T* p;\n        int sz;\n    };\n\n    X::X(X&& a) noexcept\n        :p{a.p}, sz{a.sz}  // steal representation\n    {\n        a.p = nullptr;     // set to \"empty\"\n        a.sz = 0;\n    }\n\n    void use()\n    {\n        X x{};\n        // ...\n        X y = std::move(x);\n        x = X{};   // OK\n    } // OK: x can be destroyed\n\n##### Note\n\nIdeally, that moved-from should be the default value of the type.\nEnsure that unless there is an exceptionally good reason not to.\nHowever, not all types have a default value and for some types establishing the default value can be expensive.\nThe standard requires only that the moved-from object can be destroyed.\nOften, we can easily and cheaply do better: The standard library assumes that it is possible to assign to a moved-from object.\nAlways leave the moved-from object in some (necessarily specified) valid state.\n\n##### Note\n\nUnless there is an exceptionally strong reason not to, make `x = std::move(y); y = z;` work with the conventional semantics.\n\n##### Enforcement\n\n(Not enforceable) Look for assignments to members in the move operation. If there is a default constructor, compare those assignments to the initializations in the default constructor.\n\n### <a name=\"rc-move-self\"></a>C.65: Make move assignment safe for self-assignment\n\n##### Reason\n\nIf `x = x` changes the value of `x`, people will be surprised and bad errors can occur. However, people don't usually directly write a self-assignment that turns into a move, but it can occur. However, `std::swap` is implemented using move operations so if you accidentally do `swap(a, b)` where `a` and `b` refer to the same object, failing to handle self-move could be a serious and subtle error.\n\n##### Example\n\n    class Foo {\n        string s;\n        int i;\n    public:\n        Foo& operator=(Foo&& a) noexcept;\n        // ...\n    };\n\n    Foo& Foo::operator=(Foo&& a) noexcept  // OK, but there is a cost\n    {\n        if (this == &a) return *this;  // this line is redundant\n        s = std::move(a.s);\n        i = a.i;\n        return *this;\n    }\n\nThe one-in-a-million argument against `if (this == &a) return *this;` tests from the discussion of [self-assignment](#rc-copy-self) is even more relevant for self-move.\n\n##### Note\n\nThere is no known general way of avoiding an `if (this == &a) return *this;` test for a move assignment and still getting a correct answer (i.e., after `x = x` the value of `x` is unchanged).\n\n##### Note\n\nThe ISO standard guarantees only a \"valid but unspecified\" state for the standard-library containers. Apparently this has not been a problem in about 10 years of experimental and production use. Please contact the editors if you find a counter example. The rule here is more caution and insists on complete safety.\n\n##### Example\n\nHere is a way to move a pointer without a test (imagine it as code in the implementation a move assignment):\n\n    // move from other.ptr to this->ptr\n    T* temp = other.ptr;\n    other.ptr = nullptr;\n    delete ptr; // in self-move, this->ptr is also null; delete is a no-op\n    ptr = temp; // in self-move, the original ptr is restored\n\n##### Enforcement\n\n* (Moderate) In the case of self-assignment, a move assignment operator should not leave the object holding pointer members that have been `delete`d or set to `nullptr`.\n* (Not enforceable) Look at the use of standard-library container types (incl. `string`) and consider them safe for ordinary (not life-critical) uses.\n\n### <a name=\"rc-move-noexcept\"></a>C.66: Make move operations `noexcept`\n\n##### Reason\n\nA throwing move violates most people's reasonable assumptions.\nA non-throwing move will be used more efficiently by standard-library and language facilities.\n\n##### Example\n\n    template<typename T>\n    class Vector {\n    public:\n        Vector(Vector&& a) noexcept :elem{a.elem}, sz{a.sz} { a.elem = nullptr; a.sz = 0; }\n        Vector& operator=(Vector&& a) noexcept {\n            if (&a != this) {\n                delete elem;\n                elem = a.elem; a.elem = nullptr;\n                sz   = a.sz;   a.sz   = 0;\n            }\n            return *this;\n        }\n        // ...\n    private:\n        T* elem;\n        int sz;\n    };\n\nThese operations do not throw.\n\n##### Example, bad\n\n    template<typename T>\n    class Vector2 {\n    public:\n        Vector2(Vector2&& a) noexcept { *this = a; }             // just use the copy\n        Vector2& operator=(Vector2&& a) noexcept { *this = a; }  // just use the copy\n        // ...\n    private:\n        T* elem;\n        int sz;\n    };\n\nThis `Vector2` is not just inefficient, but since a vector copy requires allocation, it can throw.\n\n##### Enforcement\n\n(Simple) A move operation should be marked `noexcept`.\n\n### <a name=\"rc-copy-virtual\"></a>C.67: A polymorphic class should suppress public copy/move\n\n##### Reason\n\nA *polymorphic class* is a class that defines or inherits at least one virtual function. It is likely that it will be used as a base class for other derived classes with polymorphic behavior. If it is accidentally passed by value, with the implicitly generated copy constructor and assignment, we risk slicing: only the base portion of a derived object will be copied, and the polymorphic behavior will be corrupted.\n\nIf the class has no data, `=delete` the copy/move functions. Otherwise, make them protected.\n\n##### Example, bad\n\n    class B { // BAD: polymorphic base class doesn't suppress copying\n    public:\n        virtual char m() { return 'B'; }\n        // ... nothing about copy operations, so uses default ...\n    };\n\n    class D : public B {\n    public:\n        char m() override { return 'D'; }\n        // ...\n    };\n\n    void f(B& b)\n    {\n        auto b2 = b; // oops, slices the object; b2.m() will return 'B'\n    }\n\n    D d;\n    f(d);\n\n##### Example\n\n    class B { // GOOD: polymorphic class suppresses copying\n    public:\n        B() = default;\n        B(const B&) = delete;\n        B& operator=(const B&) = delete;\n        virtual char m() { return 'B'; }\n        // ...\n    };\n\n    class D : public B {\n    public:\n        char m() override { return 'D'; }\n        // ...\n    };\n\n    void f(B& b)\n    {\n        auto b2 = b; // ok, compiler will detect inadvertent copying, and protest\n    }\n\n    D d;\n    f(d);\n\n##### Note\n\nIf you need to create deep copies of polymorphic objects, use `clone()` functions: see [C.130](#rh-copy).\n\n##### Exception\n\nClasses that represent exception objects need both to be polymorphic and copy-constructible.\n\n##### Enforcement\n\n* Flag a polymorphic class with a public copy operation.\n* Flag an assignment of polymorphic class objects.\n\n## C.other: Other default operation rules\n\nIn addition to the operations for which the language offers default implementations,\nthere are a few operations that are so foundational that specific rules for their definition are needed:\ncomparisons, `swap`, and `hash`.\n\n### <a name=\"rc-eqdefault\"></a>C.80: Use `=default` if you have to be explicit about using the default semantics\n\n##### Reason\n\nThe compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler.\n\n##### Example\n\n    class Tracer {\n        string message;\n    public:\n        Tracer(const string& m) : message{m} { cerr << \"entering \" << message << '\\n'; }\n        ~Tracer() { cerr << \"exiting \" << message << '\\n'; }\n\n        Tracer(const Tracer&) = default;\n        Tracer& operator=(const Tracer&) = default;\n        Tracer(Tracer&&) noexcept = default;\n        Tracer& operator=(Tracer&&) noexcept = default;\n    };\n\nBecause we defined the destructor, we must define the copy and move operations. The `= default` is the best and simplest way of doing that.\n\n##### Example, bad\n\n    class Tracer2 {\n        string message;\n    public:\n        Tracer2(const string& m) : message{m} { cerr << \"entering \" << message << '\\n'; }\n        ~Tracer2() { cerr << \"exiting \" << message << '\\n'; }\n\n        Tracer2(const Tracer2& a) : message{a.message} {}\n        Tracer2& operator=(const Tracer2& a) { message = a.message; return *this; }\n        Tracer2(Tracer2&& a) noexcept :message{a.message} {}\n        Tracer2& operator=(Tracer2&& a) noexcept { message = a.message; return *this; }\n    };\n\nWriting out the bodies of the copy and move operations is verbose, tedious, and error-prone. A compiler does it better.\n\n##### Enforcement\n\n(Moderate) The body of a user-defined operation should not have the same semantics as the compiler-generated version, because that would be redundant.\n\n### <a name=\"rc-delete\"></a>C.81: Use `=delete` when you want to disable default behavior (without wanting an alternative)\n\n##### Reason\n\nIn a few cases, a default operation is not desirable.\n\n##### Example\n\n    class Immortal {\n    public:\n        ~Immortal() = delete;   // do not allow destruction\n        // ...\n    };\n\n    void use()\n    {\n        Immortal ugh;   // error: ugh cannot be destroyed\n        Immortal* p = new Immortal{};\n        delete p;       // error: cannot destroy *p\n    }\n\n##### Example\n\nA `unique_ptr` can be moved, but not copied. To achieve that its copy operations are deleted. To avoid copying it is necessary to `=delete` its copy operations from lvalues:\n\n    template<class T, class D = default_delete<T>> class unique_ptr {\n    public:\n        // ...\n        constexpr unique_ptr() noexcept;\n        explicit unique_ptr(pointer p) noexcept;\n        // ...\n        unique_ptr(unique_ptr&& u) noexcept;   // move constructor\n        // ...\n        unique_ptr(const unique_ptr&) = delete; // disable copy from lvalue\n        // ...\n    };\n\n    unique_ptr<int> make();   // make \"something\" and return it by moving\n\n    void f()\n    {\n        unique_ptr<int> pi {};\n        auto pi2 {pi};      // error: no move constructor from lvalue\n        auto pi3 {make()};  // OK, move: the result of make() is an rvalue\n    }\n\nNote that deleted functions should be public.\n\n##### Enforcement\n\nThe elimination of a default operation is (should be) based on the desired semantics of the class. Consider such classes suspect, but maintain a \"positive list\" of classes where a human has asserted that the semantics is correct.\n\n### <a name=\"rc-ctor-virtual\"></a>C.82: Don't call virtual functions in constructors and destructors\n\n##### Reason\n\nThe function called will be that of the object constructed so far, rather than a possibly overriding function in a derived class.\nThis can be most confusing.\nWorse, a direct or indirect call to an unimplemented pure virtual function from a constructor or destructor results in undefined behavior.\n\n##### Example, bad\n\n    class Base {\n    public:\n        virtual void f() = 0;   // not implemented\n        virtual void g();       // implemented with Base version\n        virtual void h();       // implemented with Base version\n        virtual ~Base();        // implemented with Base version\n    };\n\n    class Derived : public Base {\n    public:\n        void g() override;   // provide Derived implementation\n        void h() final;      // provide Derived implementation\n\n        Derived()\n        {\n            // BAD: attempt to call an unimplemented virtual function\n            f();\n\n            // BAD: will call Derived::g, not dispatch further virtually\n            g();\n\n            // GOOD: explicitly state intent to call only the visible version\n            Derived::g();\n\n            // ok, no qualification needed, h is final\n            h();\n        }\n    };\n\nNote that calling a specific explicitly qualified function is not a virtual call even if the function is `virtual`.\n\n**See also** [factory functions](#rc-factory) for how to achieve the effect of a call to a derived class function without risking undefined behavior.\n\n##### Note\n\nThere is nothing inherently wrong with calling virtual functions from constructors and destructors.\nThe semantics of such calls is type safe.\nHowever, experience shows that such calls are rarely needed, easily confuse maintainers, and become a source of errors when used by novices.\n\n##### Enforcement\n\n* Flag calls of virtual functions from constructors and destructors.\n\n### <a name=\"rc-swap\"></a>C.83: For value-like types, consider providing a `noexcept` swap function\n\n##### Reason\n\nA `swap` can be handy for implementing a number of idioms, from smoothly moving objects around to implementing assignment easily to providing a guaranteed commit function that enables strongly error-safe calling code. Consider using swap to implement copy assignment in terms of copy construction. See also [destructors, deallocation, and swap must never fail](#re-never-fail).\n\n##### Example, good\n\n    class Foo {\n    public:\n        void swap(Foo& rhs) noexcept\n        {\n            m1.swap(rhs.m1);\n            std::swap(m2, rhs.m2);\n        }\n    private:\n        Bar m1;\n        int m2;\n    };\n\nProviding a non-member `swap` function in the same namespace as your type for callers' convenience.\n\n    void swap(Foo& a, Foo& b)\n    {\n        a.swap(b);\n    }\n\n##### Enforcement\n\n* Non-trivially copyable types should provide a member swap or a free swap overload.\n* (Simple) When a class has a `swap` member function, it should be declared `noexcept`.\n\n### <a name=\"rc-swap-fail\"></a>C.84: A `swap` function must not fail\n\n##### Reason\n\n `swap` is widely used in ways that are assumed never to fail and programs cannot easily be written to work correctly in the presence of a failing `swap`. The standard-library containers and algorithms will not work correctly if a swap of an element type fails.\n\n##### Example, bad\n\n    void swap(My_vector& x, My_vector& y)\n    {\n        auto tmp = x;   // copy elements\n        x = y;\n        y = tmp;\n    }\n\nThis is not just slow, but if a memory allocation occurs for the elements in `tmp`, this `swap` could throw and would make STL algorithms fail if used with them.\n\n##### Enforcement\n\n(Simple) When a class has a `swap` member function, it should be declared `noexcept`.\n\n### <a name=\"rc-swap-noexcept\"></a>C.85: Make `swap` `noexcept`\n\n##### Reason\n\n [A `swap` must not fail](#rc-swap-fail).\nIf a `swap` tries to exit with an exception, it's a bad design error and the program had better terminate.\n\n##### Enforcement\n\n(Simple) When a class has a `swap` member function, it should be declared `noexcept`.\n\n### <a name=\"rc-eq\"></a>C.86: Make `==` symmetric with respect to operand types and `noexcept`\n\n##### Reason\n\nAsymmetric treatment of operands is surprising and a source of errors where conversions are possible.\n`==` is a fundamental operation and programmers should be able to use it without fear of failure.\n\n##### Example\n\n    struct X {\n        string name;\n        int number;\n    };\n\n    bool operator==(const X& a, const X& b) noexcept {\n        return a.name == b.name && a.number == b.number;\n    }\n\n##### Example, bad\n\n    class B {\n        string name;\n        int number;\n        bool operator==(const B& a) const {\n            return name == a.name && number == a.number;\n        }\n        // ...\n    };\n\n`B`'s comparison accepts conversions for its second operand, but not its first.\n\n##### Note\n\nIf a class has a failure state, like `double`'s `NaN`, there is a temptation to make a comparison against the failure state throw.\nThe alternative is to make two failure states compare equal and any valid state compare false against the failure state.\n\n##### Note\n\nThis rule applies to all the usual comparison operators: `!=`, `<`, `<=`, `>`, and `>=`.\n\n##### Enforcement\n\n* Flag an `operator==()` for which the argument types differ; same for other comparison operators: `!=`, `<`, `<=`, `>`, and `>=`.\n* Flag member `operator==()`s; same for other comparison operators: `!=`, `<`, `<=`, `>`, and `>=`.\n\n### <a name=\"rc-eq-base\"></a>C.87: Beware of `==` on base classes\n\n##### Reason\n\nIt is really hard to write a foolproof and useful `==` for a hierarchy.\n\n##### Example, bad\n\n    class B {\n        string name;\n        int number;\n    public:\n        virtual bool operator==(const B& a) const\n        {\n             return name == a.name && number == a.number;\n        }\n        // ...\n    };\n\n`B`'s comparison accepts conversions for its second operand, but not its first.\n\n    class D : public B {\n        char character;\n    public:\n        virtual bool operator==(const D& a) const\n        {\n            return B::operator==(a) && character == a.character;\n        }\n        // ...\n    };\n\n    B b = ...\n    D d = ...\n    b == d;    // compares name and number, ignores d's character\n    d == b;    // compares name and number, ignores d's character\n    D d2;\n    d == d2;   // compares name, number, and character\n    B& b2 = d2;\n    b2 == d;   // compares name and number, ignores d2's and d's character\n\nOf course there are ways of making `==` work in a hierarchy, but the naive approaches do not scale.\n\n##### Note\n\nThis rule applies to all the usual comparison operators: `!=`, `<`, `<=`, `>`, `>=`, and `<=>`.\n\n##### Enforcement\n\n* Flag a virtual `operator==()`; same for other comparison operators: `!=`, `<`, `<=`, `>`, `>=`, and `<=>`.\n\n### <a name=\"rc-hash\"></a>C.89: Make a `hash` `noexcept`\n\n##### Reason\n\nUsers of hashed containers use hash indirectly and don't expect simple access to throw.\nIt's a standard-library requirement.\n\n##### Example, bad\n\n    template<>\n    struct hash<My_type> {  // thoroughly bad hash specialization\n        using result_type = size_t;\n        using argument_type = My_type;\n\n        size_t operator()(const My_type & x) const\n        {\n            size_t xs = x.s.size();\n            if (xs < 4) throw Bad_My_type{};    // \"Nobody expects the Spanish inquisition!\"\n            return hash<size_t>()(x.s.size()) ^ trim(x.s);\n        }\n    };\n\n    int main()\n    {\n        unordered_map<My_type, int> m;\n        My_type mt{ \"asdfg\" };\n        m[mt] = 7;\n        cout << m[My_type{ \"asdfg\" }] << '\\n';\n    }\n\nIf you have to define a `hash` specialization, try simply to let it combine standard-library `hash` specializations with `^` (xor).\nThat tends to work better than \"cleverness\" for non-specialists.\n\n##### Enforcement\n\n* Flag throwing `hash`es.\n\n### <a name=\"rc-memset\"></a>C.90: Rely on constructors and assignment operators, not `memset` and `memcpy`\n\n##### Reason\n\nThe standard C++ mechanism to construct an instance of a type is to call its constructor. As specified in guideline [C.41](#rc-complete): a constructor should create a fully initialized object. No additional initialization, such as by `memcpy`, should be required.\nA type will provide a copy constructor and/or copy assignment operator to appropriately make a copy of the class, preserving the type's invariants.  Using memcpy to copy a non-trivially copyable type has undefined behavior.  Frequently this results in slicing, or data corruption.\n\n##### Example, good\n\n    struct base {\n        virtual void update() = 0;\n        std::shared_ptr<int> sp;\n    };\n\n    struct derived : public base {\n        void update() override {}\n    };\n\n##### Example, bad\n\n    void init(derived& a)\n    {\n        memset(&a, 0, sizeof(derived));\n    }\n\nThis is type-unsafe and overwrites the vtable.\n\n##### Example, bad\n\n    void copy(derived& a, derived& b)\n    {\n        memcpy(&a, &b, sizeof(derived));\n    }\n\nThis is also type-unsafe and overwrites the vtable.\n\n##### Enforcement\n\n* Flag passing a non-trivially-copyable type to `memset` or `memcpy`.\n\n## <a name=\"ss-containers\"></a>C.con: Containers and other resource handles\n\nA container is an object holding a sequence of objects of some type; `std::vector` is the archetypical container.\nA resource handle is a class that owns a resource; `std::vector` is the typical resource handle; its resource is its sequence of elements.\n\nSummary of container rules:\n\n* [C.100: Follow the STL when defining a container](#rcon-stl)\n* [C.101: Give a container value semantics](#rcon-val)\n* [C.102: Give a container move operations](#rcon-move)\n* [C.103: Give a container an initializer list constructor](#rcon-init)\n* [C.104: Give a container a default constructor that sets it to empty](#rcon-empty)\n* ???\n* [C.109: If a resource handle has pointer semantics, provide `*` and `->`](#rcon-ptr)\n\n**See also**: [Resources](#s-resource)\n\n\n### <a name=\"rcon-stl\"></a>C.100: Follow the STL when defining a container\n\n##### Reason\n\nThe STL containers are familiar to most C++ programmers and a fundamentally sound design.\n\n##### Note\n\nThere are of course other fundamentally sound design styles and sometimes reasons to depart from\nthe style of the standard library, but in the absence of a solid reason to differ, it is simpler\nand easier for both implementers and users to follow the standard.\n\nIn particular, `std::vector` and `std::map` provide useful relatively simple models.\n\n##### Example\n\n    // simplified (e.g., no allocators):\n\n    template<typename T>\n    class Sorted_vector {\n        using value_type = T;\n        // ... iterator types ...\n\n        Sorted_vector() = default;\n        Sorted_vector(initializer_list<T>);    // initializer-list constructor: sort and store\n        Sorted_vector(const Sorted_vector&) = default;\n        Sorted_vector(Sorted_vector&&) noexcept = default;\n        Sorted_vector& operator=(const Sorted_vector&) = default;     // copy assignment\n        Sorted_vector& operator=(Sorted_vector&&) noexcept = default; // move assignment\n        ~Sorted_vector() = default;\n\n        Sorted_vector(const std::vector<T>& v);   // store and sort\n        Sorted_vector(std::vector<T>&& v);        // sort and \"steal representation\"\n\n        const T& operator[](int i) const { return rep[i]; }\n        // no non-const direct access to preserve order\n\n        void push_back(const T&);   // insert in the right place (not necessarily at back)\n        void push_back(T&&);        // insert in the right place (not necessarily at back)\n\n        // ... cbegin(), cend() ...\n    private:\n        std::vector<T> rep;  // use a std::vector to hold elements\n    };\n\n    template<typename T> bool operator==(const Sorted_vector<T>&, const Sorted_vector<T>&);\n    template<typename T> bool operator!=(const Sorted_vector<T>&, const Sorted_vector<T>&);\n    // ...\n\nHere, the STL style is followed, but incompletely.\nThat's not uncommon.\nProvide only as much functionality as makes sense for a specific container.\nThe key is to define the conventional constructors, assignments, destructors, and iterators\n(as meaningful for the specific container) with their conventional semantics.\nFrom that base, the container can be expanded as needed.\nHere, special constructors from `std::vector` were added.\n\n##### Enforcement\n\n???\n\n### <a name=\"rcon-val\"></a>C.101: Give a container value semantics\n\n##### Reason\n\nRegular objects are simpler to think and reason about than irregular ones.\nFamiliarity.\n\n##### Note\n\nIf meaningful, make a container `Regular` (the concept).\nIn particular, ensure that an object compares equal to its copy.\n\n##### Example\n\n    void f(const Sorted_vector<string>& v)\n    {\n        Sorted_vector<string> v2 {v};\n        if (v != v2)\n            cout << \"Behavior against reason and logic.\\n\";\n        // ...\n    }\n\n##### Enforcement\n\n???\n\n### <a name=\"rcon-move\"></a>C.102: Give a container move operations\n\n##### Reason\n\nContainers tend to get large; without a move constructor and a copy constructor an object can be\nexpensive to move around, thus tempting people to pass pointers to it around and getting into\nresource management problems.\n\n##### Example\n\n    Sorted_vector<int> read_sorted(istream& is)\n    {\n        vector<int> v;\n        cin >> v;   // assume we have a read operation for vectors\n        Sorted_vector<int> sv = v;  // sorts\n        return sv;\n    }\n\nA user can reasonably assume that returning a standard-like container is cheap.\n\n##### Enforcement\n\n???\n\n### <a name=\"rcon-init\"></a>C.103: Give a container an initializer list constructor\n\n##### Reason\n\nPeople expect to be able to initialize a container with a set of values.\nFamiliarity.\n\n##### Example\n\n    Sorted_vector<int> sv {1, 3, -1, 7, 0, 0}; // Sorted_vector sorts elements as needed\n\n##### Enforcement\n\n???\n\n### <a name=\"rcon-empty\"></a>C.104: Give a container a default constructor that sets it to empty\n\n##### Reason\n\nTo make it `Regular`.\n\n##### Example\n\n    vector<Sorted_sequence<string>> vs(100);    // 100 Sorted_sequences each with the value \"\"\n\n##### Enforcement\n\n???\n\n### <a name=\"rcon-ptr\"></a>C.109: If a resource handle has pointer semantics, provide `*` and `->`\n\n##### Reason\n\nThat's what is expected from pointers.\nFamiliarity.\n\n##### Example\n\n    ???\n\n##### Enforcement\n\n???\n\n## <a name=\"ss-lambdas\"></a>C.lambdas: Function objects and lambdas\n\nA function object is an object supplying an overloaded `()` so that you can call it.\nA lambda expression (colloquially often shortened to \"a lambda\") is a notation for generating a function object.\nFunction objects should be cheap to copy (and therefore [passed by value](#rf-in)).\n\nSummary:\n\n* [F.10: If an operation can be reused, give it a name](#rf-name)\n* [F.11: Use an unnamed lambda if you need a simple function object in one place only](#rf-lambda)\n* [F.50: Use a lambda when a function won't do (to capture local variables, or to write a local function)](#rf-capture-vs-overload)\n* [F.52: Prefer capturing by reference in lambdas that will be used locally, including passed to algorithms](#rf-reference-capture)\n* [F.53: Avoid capturing by reference in lambdas that will be used non-locally, including returned, stored on the heap, or passed to another thread](#rf-value-capture)\n* [ES.28: Use lambdas for complex initialization, especially of `const` variables](#res-lambda-init)\n\n## <a name=\"ss-hier\"></a>C.hier: Class hierarchies (OOP)\n\nA class hierarchy is constructed to represent a set of hierarchically organized concepts (only).\nTypically base classes act as interfaces.\nThere are two major uses for hierarchies, often named implementation inheritance and interface inheritance.\n\nClass hierarchy rule summary:\n\n* [C.120: Use class hierarchies to represent concepts with inherent hierarchical structure (only)](#rh-domain)\n* [C.121: If a base class is used as an interface, make it a pure abstract class](#rh-abstract)\n* [C.122: Use abstract classes as interfaces when complete separation of interface and implementation is needed](#rh-separation)\n\nDesigning rules for classes in a hierarchy summary:\n\n* [C.126: An abstract class typically doesn't need a user-written constructor](#rh-abstract-ctor)\n* [C.127: A class with a virtual function should have a virtual or protected destructor](#rh-dtor)\n* [C.128: Virtual functions should specify exactly one of `virtual`, `override`, or `final`](#rh-override)\n* [C.129: When designing a class hierarchy, distinguish between implementation inheritance and interface inheritance](#rh-kind)\n* [C.130: For making deep copies of polymorphic classes prefer a virtual `clone` function instead of public copy construction/assignment](#rh-copy)\n* [C.131: Avoid trivial getters and setters](#rh-get)\n* [C.132: Don't make a function `virtual` without reason](#rh-virtual)\n* [C.133: Avoid `protected` data](#rh-protected)\n* [C.134: Ensure all non-`const` data members have the same access level](#rh-public)\n* [C.135: Use multiple inheritance to represent multiple distinct interfaces](#rh-mi-interface)\n* [C.136: Use multiple inheritance to represent the union of implementation attributes](#rh-mi-implementation)\n* [C.137: Use `virtual` bases to avoid overly general base classes](#rh-vbase)\n* [C.138: Create an overload set for a derived class and its bases with `using`](#rh-using)\n* [C.139: Use `final` on classes sparingly](#rh-final)\n* [C.140: Do not provide different default arguments for a virtual function and an overrider](#rh-virtual-default-arg)\n\nAccessing objects in a hierarchy rule summary:\n\n* [C.145: Access polymorphic objects through pointers and references](#rh-poly)\n* [C.146: Use `dynamic_cast` where class hierarchy navigation is unavoidable](#rh-dynamic_cast)\n* [C.147: Use `dynamic_cast` to a reference type when failure to find the required class is considered an error](#rh-ref-cast)\n* [C.148: Use `dynamic_cast` to a pointer type when failure to find the required class is considered a valid alternative](#rh-ptr-cast)\n* [C.149: Use `unique_ptr` or `shared_ptr` to avoid forgetting to `delete` objects created using `new`](#rh-smart)\n* [C.150: Use `make_unique()` to construct objects owned by `unique_ptr`s](#rh-make_unique)\n* [C.151: Use `make_shared()` to construct objects owned by `shared_ptr`s](#rh-make_shared)\n* [C.152: Never assign a pointer to an array of derived class objects to a pointer to its base](#rh-array)\n* [C.153: Prefer virtual function to casting](#rh-use-virtual)\n\n### <a name=\"rh-domain\"></a>C.120: Use class hierarchies to represent concepts with inherent hierarchical structure (only)\n\n##### Reason\n\nDirect representation of ideas in code eases comprehension and maintenance. Make sure the idea represented in the base class exactly matches all derived types and there is not a better way to express it than using the tight coupling of inheritance.\n\nDo *not* use inheritance when simply having a data member will do. Usually this means that the derived type needs to override a base virtual function or needs access to a protected member.\n\n##### Example\n\n    class DrawableUIElement {\n    public:\n        virtual void render() const = 0;\n        // ...\n    };\n\n    class AbstractButton : public DrawableUIElement {\n    public:\n        virtual void onClick() = 0;\n        // ...\n    };\n\n    class PushButton : public AbstractButton {\n        void render() const override;\n        void onClick() override;\n        // ...\n    };\n\n    class Checkbox : public AbstractButton {\n    // ...\n    };\n\n##### Example, bad\n\nDo *not* represent non-hierarchical domain concepts as class hierarchies.\n\n    template<typename T>\n    class Container {\n    public:\n        // list operations:\n        virtual T& get() = 0;\n        virtual void put(T&) = 0;\n        virtual void insert(Position) = 0;\n        // ...\n        // vector operations:\n        virtual T& operator[](int) = 0;\n        virtual void sort() = 0;\n        // ...\n        // tree operations:\n        virtual void balance() = 0;\n        // ...\n    };\n\nHere most overriding classes cannot implement most of the functions required in the interface well.\nThus the base class becomes an implementation burden.\nFurthermore, the user of `Container` cannot rely on the member functions actually performing meaningful operations reasonably efficiently;\nit might throw an exception instead.\nThus users have to resort to run-time checking and/or\nnot using this (over)general interface in favor of a particular interface found by a run-time type inquiry (e.g., a `dynamic_cast`).\n\n##### Enforcement\n\n* Look for classes with lots of members that do nothing but throw.\n* Flag every use of a non-public base class `B` where the derived class `D` does not override a virtual function or access a protected member in `B`, and `B` is not one of the following: empty, a template parameter or parameter pack of `D`, a class template specialized with `D`.\n\n### <a name=\"rh-abstract\"></a>C.121: If a base class is used as an interface, make it a pure abstract class\n\n##### Reason\n\nA class is more stable (less brittle) if it does not contain data.\nInterfaces should normally be composed entirely of public pure virtual functions and a default/empty virtual destructor.\n\n##### Example\n\n    class My_interface {\n    public:\n        // ... only pure virtual functions here ...\n        virtual ~My_interface() {}   // or =default\n    };\n\n##### Example, bad\n\n    class Goof {\n    public:\n        // ... only pure virtual functions here ...\n        // no virtual destructor\n    };\n\n    class Derived : public Goof {\n        string s;\n        // ...\n    };\n\n    void use()\n    {\n        unique_ptr<Goof> p {new Derived{\"here we go\"}};\n        f(p.get()); // use Derived through the Goof interface\n        g(p.get()); // use Derived through the Goof interface\n    } // leak\n\nThe `Derived` is `delete`d through its `Goof` interface, so its `string` is leaked.\nGive `Goof` a virtual destructor and all is well.\n\n\n##### Enforcement\n\n* Warn on any class that contains data members and also has an overridable (non-`final`) virtual function that wasn't inherited from a base class.\n\n### <a name=\"rh-separation\"></a>C.122: Use abstract classes as interfaces when complete separation of interface and implementation is needed\n\n##### Reason\n\nSuch as on an ABI (link) boundary.\n\n##### Example\n\n    struct Device {\n        virtual ~Device() = default;\n        virtual void write(span<const char> outbuf) = 0;\n        virtual void read(span<char> inbuf) = 0;\n    };\n\n    class D1 : public Device {\n        // ... data ...\n\n        void write(span<const char> outbuf) override;\n        void read(span<char> inbuf) override;\n    };\n\n    class D2 : public Device {\n        // ... different data ...\n\n        void write(span<const char> outbuf) override;\n        void read(span<char> inbuf) override;\n    };\n\nA user can now use `D1`s and `D2`s interchangeably through the interface provided by `Device`.\nFurthermore, we can update `D1` and `D2` in ways that are not binary compatible with older versions as long as all access goes through `Device`.\n\n##### Enforcement\n\n    ???\n\n## C.hierclass: Designing classes in a hierarchy:\n\n### <a name=\"rh-abstract-ctor\"></a>C.126: An abstract class typically doesn't need a user-written constructor\n\n##### Reason\n\nAn abstract class typically does not have any data for a constructor to initialize.\n\n##### Example\n\n    class Shape {\n    public:\n        // no user-written constructor needed in abstract base class\n        virtual Point center() const = 0;    // pure virtual\n        virtual void move(Point to) = 0;\n        // ... more pure virtual functions ...\n        virtual ~Shape() {}                 // destructor\n    };\n\n    class Circle : public Shape {\n    public:\n        Circle(Point p, int rad);           // constructor in derived class\n        Point center() const override { return x; }\n    };\n\n##### Exception\n\n* A base class constructor that does work, such as registering an object somewhere, might need a constructor.\n* In extremely rare cases, you might find it reasonable for an abstract class to have a bit of data shared by all derived classes\n  (e.g., use statistics data, debug information, etc.); such classes tend to have constructors. But be warned: Such classes also tend to be prone to requiring virtual inheritance.\n\n##### Enforcement\n\nFlag abstract classes with constructors.\n\n### <a name=\"rh-dtor\"></a>C.127: A class with a virtual function should have a virtual or protected destructor\n\n##### Reason\n\nA class with a virtual function is usually (and in general) used via a pointer to base. Usually, the last user has to call delete on a pointer to base, often via a smart pointer to base, so the destructor should be public and virtual. Less commonly, if deletion through a pointer to base is not intended to be supported, the destructor should be protected and non-virtual; see [C.35](#rc-dtor-virtual).\n\n##### Example, bad\n\n    struct B {\n        virtual int f() = 0;\n        // ... no user-written destructor, defaults to public non-virtual ...\n    };\n\n    // bad: derived from a class without a virtual destructor\n    struct D : B {\n        string s {\"default\"};\n        // ...\n    };\n\n    void use()\n    {\n        unique_ptr<B> p = make_unique<D>();\n        // ...\n    } // undefined behavior, might call B::~B only and leak the string\n\n##### Note\n\nThere are people who don't follow this rule because they plan to use a class only through a `shared_ptr`: `std::shared_ptr<B> p = std::make_shared<D>(args);` Here, the shared pointer will take care of deletion, so no leak will occur from an inappropriate `delete` of the base. People who do this consistently can get a false positive, but the rule is important -- what if one was allocated using `make_unique`? It's not safe unless the author of `B` ensures that it can never be misused, such as by making all constructors private and providing a factory function to enforce the allocation with `make_shared`.\n\n##### Enforcement\n\n* A class with any virtual functions should have a destructor that is either public and virtual or else protected and non-virtual.\n* Flag `delete` of a class with a virtual function but no virtual destructor.\n\n### <a name=\"rh-override\"></a>C.128: Virtual functions should specify exactly one of `virtual`, `override`, or `final`\n\n##### Reason\n\nReadability.\nDetection of mistakes.\nWriting explicit `virtual`, `override`, or `final` is self-documenting and enables the compiler to catch mismatch of types and/or names between base and derived classes. However, writing more than one of these three is both redundant and a potential source of errors.\n\nIt's simple and clear:\n\n* `virtual` means exactly and only \"this is a new virtual function.\"\n* `override` means exactly and only \"this is a non-final overrider.\"\n* `final` means exactly and only \"this is a final overrider.\"\n\n##### Example, bad\n\n    struct B {\n        void f1(int);\n        virtual void f2(int) const;\n        virtual void f3(int);\n        // ...\n    };\n\n    struct D : B {\n        void f1(int);        // bad (hope for a warning): D::f1() hides B::f1()\n        void f2(int) const;  // bad (but conventional and valid): no explicit override\n        void f3(double);     // bad (hope for a warning): D::f3() hides B::f3()\n        // ...\n    };\n\n##### Example, good\n\n    struct Better : B {\n        void f1(int) override;        // error (caught): Better::f1() hides B::f1()\n        void f2(int) const override;\n        void f3(double) override;     // error (caught): Better::f3() hides B::f3()\n        // ...\n    };\n\n#### Discussion\n\nWe want to eliminate two particular classes of errors:\n\n* **implicit virtual**: the programmer intended the function to be implicitly virtual and it is (but readers of the code can't tell); or the programmer intended the function to be implicitly virtual but it isn't (e.g., because of a subtle parameter list mismatch); or the programmer did not intend the function to be virtual but it is (because it happens to have the same signature as a virtual in the base class)\n* **implicit override**: the programmer intended the function to be implicitly an overrider and it is (but readers of the code can't tell); or the programmer intended the function to be implicitly an overrider but it isn't (e.g., because of a subtle parameter list mismatch); or the programmer did not intend the function to be an overrider but it is (because it happens to have the same signature as a virtual in the base class -- note this problem arises whether or not the function is explicitly declared virtual, because the programmer might have intended to create either a new virtual function or a new non-virtual function)\n\nNote: On a class defined as `final`, each individual virtual function should use either `override` or `final`; there is no semantic difference in this case.\n\nNote: Use `final` on functions sparingly. It does not necessarily lead to optimization, and it precludes further overriding.\n\n##### Enforcement\n\n* Compare virtual function names in base and derived classes and flag uses of the same name that do not override.\n* Flag overrides with neither `override` nor `final`.\n* Flag function declarations that use more than one of `virtual`, `override`, and `final`.\n\n### <a name=\"rh-kind\"></a>C.129: When designing a class hierarchy, distinguish between implementation inheritance and interface inheritance\n\n##### Reason\n\nImplementation details in an interface make the interface brittle;\nthat is, make its users vulnerable to having to recompile after changes in the implementation.\nData in a base class increases the complexity of implementing the base and can lead to replication of code.\n\n##### Note\n\nDefinition:\n\n* interface inheritance is the use of inheritance to separate users from implementations,\nin particular to allow derived classes to be added and changed without affecting the users of base classes.\n* implementation inheritance is the use of inheritance to simplify implementation of new facilities\nby making useful operations available for implementers of related new operations (sometimes called \"programming by difference\").\n\nA pure interface class is simply a set of pure virtual functions; see [I.25](#ri-abstract).\n\nIn early OOP (e.g., in the 1980s and 1990s), implementation inheritance and interface inheritance were often mixed\nand bad habits die hard.\nEven now, mixtures are not uncommon in old code bases and in old-style teaching material.\n\nThe importance of keeping the two kinds of inheritance increases\n\n* with the size of a hierarchy (e.g., dozens of derived classes),\n* with the length of time the hierarchy is used (e.g., decades), and\n* with the number of distinct organizations in which a hierarchy is used\n(e.g., it can be difficult to distribute an update to a base class)\n\n\n##### Example, bad\n\n    class Shape {   // BAD, mixed interface and implementation\n    public:\n        Shape();\n        Shape(Point ce = {0, 0}, Color co = none): cent{ce}, col {co} { /* ... */}\n\n        Point center() const { return cent; }\n        Color color() const { return col; }\n\n        virtual void rotate(int) = 0;\n        virtual void move(Point p) { cent = p; redraw(); }\n\n        virtual void redraw();\n\n        // ...\n    private:\n        Point cent;\n        Color col;\n    };\n\n    class Circle : public Shape {\n    public:\n        Circle(Point c, int r) : Shape{c}, rad{r} { /* ... */ }\n\n        // ...\n    private:\n        int rad;\n    };\n\n    class Triangle : public Shape {\n    public:\n        Triangle(Point p1, Point p2, Point p3); // calculate center\n        // ...\n    };\n\nProblems:\n\n* As the hierarchy grows and more data is added to `Shape`, the constructors get harder to write and maintain.\n* Why calculate the center for the `Triangle`? We might never use it.\n* Add a data member to `Shape` (e.g., drawing style or canvas)\nand all classes derived from `Shape` and all code using `Shape` will need to be reviewed, possibly changed, and probably recompiled.\n\nThe implementation of `Shape::move()` is an example of implementation inheritance:\nwe have defined `move()` once and for all, for all derived classes.\nThe more code there is in such base class member function implementations and the more data is shared by placing it in the base,\nthe more benefits we gain - and the less stable the hierarchy is.\n\n##### Example\n\nThis Shape hierarchy can be rewritten using interface inheritance:\n\n    class Shape {  // pure interface\n    public:\n        virtual Point center() const = 0;\n        virtual Color color() const = 0;\n\n        virtual void rotate(int) = 0;\n        virtual void move(Point p) = 0;\n\n        virtual void redraw() = 0;\n\n        // ...\n    };\n\nNote that a pure interface rarely has constructors: there is nothing to construct.\n\n    class Circle : public Shape {\n    public:\n        Circle(Point c, int r, Color c) : cent{c}, rad{r}, col{c} { /* ... */ }\n\n        Point center() const override { return cent; }\n        Color color() const override { return col; }\n\n        // ...\n    private:\n        Point cent;\n        int rad;\n        Color col;\n    };\n\nThe interface is now less brittle, but there is more work in implementing the member functions.\nFor example, `center` has to be implemented by every class derived from `Shape`.\n\n##### Example, dual hierarchy\n\nHow can we gain the benefit of stable hierarchies from interface hierarchies and the benefit of implementation reuse from implementation inheritance?\nOne popular technique is dual hierarchies.\nThere are many ways of implementing the idea of dual hierarchies; here, we use a multiple-inheritance variant.\n\nFirst we devise a hierarchy of interface classes:\n\n    class Shape {   // pure interface\n    public:\n        virtual Point center() const = 0;\n        virtual Color color() const = 0;\n\n        virtual void rotate(int) = 0;\n        virtual void move(Point p) = 0;\n\n        virtual void redraw() = 0;\n\n        // ...\n    };\n\n    class Circle : public virtual Shape {   // pure interface\n    public:\n        virtual int radius() = 0;\n        // ...\n    };\n\nTo make this interface useful, we must provide its implementation classes (here, named equivalently, but in the `Impl` namespace):\n\n    class Impl::Shape : public virtual ::Shape { // implementation\n    public:\n        // constructors, destructor\n        // ...\n        Point center() const override { /* ... */ }\n        Color color() const override { /* ... */ }\n\n        void rotate(int) override { /* ... */ }\n        void move(Point p) override { /* ... */ }\n\n        void redraw() override { /* ... */ }\n\n        // ...\n    };\n\nNow `Shape` is a poor example of a class with an implementation,\nbut bear with us because this is just a simple example of a technique aimed at more complex hierarchies.\n\n    class Impl::Circle : public virtual ::Circle, public Impl::Shape {   // implementation\n    public:\n        // constructors, destructor\n\n        int radius() override { /* ... */ }\n        // ...\n    };\n\nAnd we could extend the hierarchies by adding a Smiley class (:-)):\n\n    class Smiley : public virtual Circle { // pure interface\n    public:\n        // ...\n    };\n\n    class Impl::Smiley : public virtual ::Smiley, public Impl::Circle {   // implementation\n    public:\n        // constructors, destructor\n        // ...\n    }\n\nThere are now two hierarchies:\n\n* interface: Smiley -> Circle -> Shape\n* implementation: Impl::Smiley -> Impl::Circle -> Impl::Shape\n\nSince each implementation is derived from its interface as well as its implementation base class we get a lattice (DAG):\n\n    Smiley     ->         Circle     ->  Shape\n      ^                     ^               ^\n      |                     |               |\n    Impl::Smiley -> Impl::Circle -> Impl::Shape\n\nAs mentioned, this is just one way to construct a dual hierarchy.\n\nThe implementation hierarchy can be used directly, rather than through the abstract interface.\n\n    void work_with_shape(Shape&);\n\n    int user()\n    {\n        Impl::Smiley my_smiley{ /* args */ };   // create concrete shape\n        // ...\n        my_smiley.some_member();        // use implementation class directly\n        // ...\n        work_with_shape(my_smiley);     // use implementation through abstract interface\n        // ...\n    }\n\nThis can be useful when the implementation class has members that are not offered in the abstract interface\nor if direct use of a member offers optimization opportunities (e.g., if an implementation member function is `final`).\n\n##### Note\n\nAnother (related) technique for separating interface and implementation is [Pimpl](#ri-pimpl).\n\n##### Note\n\nThere is often a choice between offering common functionality as (implemented) base class functions and freestanding functions\n(in an implementation namespace).\nBase classes give a shorter notation and easier access to shared data (in the base)\nat the cost of the functionality being available only to users of the hierarchy.\n\n##### Enforcement\n\n* Flag a derived to base conversion to a base with both data and virtual functions\n(except for calls from a derived class member to a base class member)\n* ???\n\n\n### <a name=\"rh-copy\"></a>C.130: For making deep copies of polymorphic classes prefer a virtual `clone` function instead of public copy construction/assignment\n\n##### Reason\n\nCopying a polymorphic class is discouraged due to the slicing problem, see [C.67](#rc-copy-virtual). If you really need copy semantics, copy deeply: Provide a virtual `clone` function that will copy the actual most-derived type and return an owning pointer to the new object, and then in derived classes return the derived type (use a covariant return type).\n\n##### Example\n\n    class B {\n    public:\n        B() = default;\n        virtual ~B() = default;\n        virtual gsl::owner<B*> clone() const = 0;\n    protected:\n         B(const B&) = default;\n         B& operator=(const B&) = default;\n         B(B&&) noexcept = default;\n         B& operator=(B&&) noexcept = default;\n        // ...\n    };\n\n    class D : public B {\n    public:\n        gsl::owner<D*> clone() const override\n        {\n            return new D{*this};\n        };\n    };\n\nGenerally, it is recommended to use smart pointers to represent ownership (see [R.20](#rr-owner)). However, because of language rules, the covariant return type cannot be a smart pointer: `D::clone` can't return a `unique_ptr<D>` while `B::clone` returns `unique_ptr<B>`. Therefore, you either need to consistently return `unique_ptr<B>` in all overrides, or use `owner<>` utility from the [Guidelines Support Library](#ss-views).\n\n\n\n### <a name=\"rh-get\"></a>C.131: Avoid trivial getters and setters\n\n##### Reason\n\nA trivial getter or setter adds no semantic value; the data item could just as well be `public`.\n\n##### Example\n\n    class Point {   // Bad: verbose\n        int x;\n        int y;\n    public:\n        Point(int xx, int yy) : x{xx}, y{yy} { }\n        int get_x() const { return x; }\n        void set_x(int xx) { x = xx; }\n        int get_y() const { return y; }\n        void set_y(int yy) { y = yy; }\n        // no behavioral member functions\n    };\n\nConsider making such a class a `struct` -- that is, a behaviorless bunch of variables, all public data and no member functions.\n\n    struct Point {\n        int x {0};\n        int y {0};\n    };\n\nNote that we can put default initializers on data members: [C.49: Prefer initialization to assignment in constructors](#rc-initialize).\n\n##### Note\n\nThe key to this rule is whether the semantics of the getter/setter are trivial. While it is not a complete definition of \"trivial\", consider whether there would be any difference beyond syntax if the getter/setter was a public data member instead. Examples of non-trivial semantics would be: maintaining a class invariant or converting between an internal type and an interface type.\n\n##### Enforcement\n\nFlag multiple `get` and `set` member functions that simply access a member without additional semantics.\n\n### <a name=\"rh-virtual\"></a>C.132: Don't make a function `virtual` without reason\n\n##### Reason\n\nRedundant `virtual` increases run-time and object-code size.\nA virtual function can be overridden and is thus open to mistakes in a derived class.\nA virtual function ensures code replication in a templated hierarchy.\n\n##### Example, bad\n\n    template<class T>\n    class Vector {\n    public:\n        // ...\n        virtual int size() const { return sz; }   // bad: what good could a derived class do?\n    private:\n        T* elem;   // the elements\n        int sz;    // number of elements\n    };\n\nThis kind of \"vector\" isn't meant to be used as a base class at all.\n\n##### Enforcement\n\n* Flag a class with virtual functions but no derived classes.\n* Flag a class where all member functions are virtual and have implementations.\n\n### <a name=\"rh-protected\"></a>C.133: Avoid `protected` data\n\n**Alternative formulation**: Make member data `public` or (preferably) `private`.\n\n##### Reason\n\n`protected` data is a source of complexity and errors.\n`protected` data complicates the statement of invariants.\n`protected` data inherently violates the guidance against putting data in base classes, which usually leads to having to deal with virtual inheritance as well.\n\n##### Example, bad\n\n    class Shape {\n    public:\n        // ... interface functions ...\n    protected:\n        // data for use in derived classes:\n        Color fill_color;\n        Color edge_color;\n        Style st;\n    };\n\nNow it is up to every derived `Shape` to manipulate the protected data correctly.\nThis has been popular, but also a major source of maintenance problems.\nIn a large class hierarchy, the consistent use of protected data is hard to maintain because there can be a lot of code,\nspread over a lot of classes.\nThe set of classes that can touch that data is open: anyone can derive a new class and start manipulating the protected data.\nOften, it is not possible to examine the complete set of classes, so any change to the representation of the class becomes infeasible.\nThere is no enforced invariant for the protected data; it is much like a set of global variables.\nThe protected data has de facto become global to a large body of code.\n\n##### Note\n\nProtected data often looks tempting to enable arbitrary improvements through derivation.\nOften, what you get is unprincipled changes and errors.\n[Prefer `private` data](#rc-private) with a well-specified and enforced invariant.\nAlternatively, and often better, [keep data out of any class used as an interface](#rh-abstract).\n\n##### Note\n\nProtected member function can be just fine.\n\n##### Enforcement\n\nFlag classes with `protected` data.\n\n### <a name=\"rh-public\"></a>C.134: Ensure all non-`const` data members have the same access level\n\n##### Reason\n\nPrevention of logical confusion leading to errors.\nIf the non-`const` data members don't have the same access level, the type is confused about what it's trying to do.\nIs it a type that maintains an invariant or simply a collection of values?\n\n##### Discussion\n\nThe core question is: What code is responsible for maintaining a meaningful/correct value for that variable?\n\nThere are exactly two kinds of data members:\n\n* A: Ones that don't participate in the object's invariant. Any combination of values for these members is valid.\n* B: Ones that do participate in the object's invariant. Not every combination of values is meaningful (else there'd be no invariant). Therefore all code that has write access to these variables must know about the invariant, know the semantics, and know (and actively implement and enforce) the rules for keeping the values correct.\n\nData members in category A should just be `public` (or, more rarely, `protected` if you only want derived classes to see them). They don't need encapsulation. All code in the system might as well see and manipulate them.\n\nData members in category B should be `private` or `const`. This is because encapsulation is important. To make them non-`private` and non-`const` would mean that the object can't control its own state: An unbounded amount of code beyond the class would need to know about the invariant and participate in maintaining it accurately -- if these data members were `public`, that would be all calling code that uses the object; if they were `protected`, it would be all the code in current and future derived classes. This leads to brittle and tightly coupled code that quickly becomes a nightmare to maintain. Any code that inadvertently sets the data members to an invalid or unexpected combination of values would corrupt the object and all subsequent uses of the object.\n\nMost classes are either all A or all B:\n\n* *All public*: If you're writing an aggregate bundle-of-variables without an invariant across those variables, then all the variables should be `public`.\n  [By convention, declare such classes `struct` rather than `class`](#rc-struct)\n* *All private*: If you're writing a type that maintains an invariant, then all the non-`const` variables should be private -- it should be encapsulated.\n\n##### Exception\n\nOccasionally classes will mix A and B, usually for debug reasons. An encapsulated object might contain something like non-`const` debug instrumentation that isn't part of the invariant and so falls into category A -- it isn't really part of the object's value or meaningful observable state either. In that case, the A parts should be treated as A's (made `public`, or in rarer cases `protected` if they should be visible only to derived classes) and the B parts should still be treated like B's (`private` or `const`).\n\n##### Enforcement\n\nFlag any class that has non-`const` data members with different access levels.\n\n### <a name=\"rh-mi-interface\"></a>C.135: Use multiple inheritance to represent multiple distinct interfaces\n\n##### Reason\n\nNot all classes will necessarily support all interfaces, and not all callers will necessarily want to deal with all operations.\nEspecially to break apart monolithic interfaces into \"aspects\" of behavior supported by a given derived class.\n\n##### Example\n\n    class iostream : public istream, public ostream {   // very simplified\n        // ...\n    };\n\n`istream` provides the interface to input operations; `ostream` provides the interface to output operations.\n`iostream` provides the union of the `istream` and `ostream` interfaces and the synchronization needed to allow both on a single stream.\n\n##### Note\n\nThis is a very common use of inheritance because the need for multiple different interfaces to an implementation is common\nand such interfaces are often not easily or naturally organized into a single-rooted hierarchy.\n\n##### Note\n\nSuch interfaces are typically abstract classes.\n\n##### Enforcement\n\n???\n\n### <a name=\"rh-mi-implementation\"></a>C.136: Use multiple inheritance to represent the union of implementation attributes\n\n##### Reason\n\nSome forms of mixins have state and often operations on that state.\nIf the operations are virtual the use of inheritance is necessary, if not using inheritance can avoid boilerplate and forwarding.\n\n##### Example\n\n    class iostream : public istream, public ostream {   // very simplified\n        // ...\n    };\n\n`istream` provides the interface to input operations (and some data); `ostream` provides the interface to output operations (and some data).\n`iostream` provides the union of the `istream` and `ostream` interfaces and the synchronization needed to allow both on a single stream.\n\n##### Note\n\nThis is a relatively rare use because implementation can often be organized into a single-rooted hierarchy.\n\n##### Example\n\nSometimes, an \"implementation attribute\" is more like a \"mixin\" that determines the behavior of an implementation and injects\nmembers to enable the implementation of the policies it requires.\nFor example, see `std::enable_shared_from_this`\nor various bases from boost.intrusive (e.g. `list_base_hook` or `intrusive_ref_counter`).\n\n##### Enforcement\n\n???\n\n### <a name=\"rh-vbase\"></a>C.137: Use `virtual` bases to avoid overly general base classes\n\n##### Reason\n\n Allow separation of shared data and interface.\n To avoid all shared data to being put into an ultimate base class.\n\n##### Example\n\n    struct Interface {\n        virtual void f();\n        virtual int g();\n        // ... no data here ...\n    };\n\n    class Utility {  // with data\n        void utility1();\n        virtual void utility2();    // customization point\n    public:\n        int x;\n        int y;\n    };\n\n    class Derive1 : public Interface, virtual protected Utility {\n        // override Interface functions\n        // Maybe override Utility virtual functions\n        // ...\n    };\n\n    class Derive2 : public Interface, virtual protected Utility {\n        // override Interface functions\n        // Maybe override Utility virtual functions\n        // ...\n    };\n\nFactoring out `Utility` makes sense if many derived classes share significant \"implementation details.\"\n\n\n##### Note\n\nObviously, the example is too \"theoretical\", but it is hard to find a *small* realistic example.\n`Interface` is the root of an [interface hierarchy](#rh-abstract)\nand `Utility` is the root of an [implementation hierarchy](#rh-kind).\nHere is [a slightly more realistic example](https://www.quora.com/What-are-the-uses-and-advantages-of-virtual-base-class-in-C%2B%2B/answer/Lance-Diduck) with an explanation.\n\n##### Note\n\nOften, linearization of a hierarchy is a better solution.\n\n##### Enforcement\n\nFlag mixed interface and implementation hierarchies.\n\n### <a name=\"rh-using\"></a>C.138: Create an overload set for a derived class and its bases with `using`\n\n##### Reason\n\nWithout a using declaration, member functions in the derived class hide the entire inherited overload sets.\n\n##### Example, bad\n\n    #include <iostream>\n    class B {\n    public:\n        virtual int f(int i) { std::cout << \"f(int): \"; return i; }\n        virtual double f(double d) { std::cout << \"f(double): \"; return d; }\n        virtual ~B() = default;\n    };\n    class D: public B {\n    public:\n        int f(int i) override { std::cout << \"f(int): \"; return i + 1; }\n    };\n    int main()\n    {\n        D d;\n        std::cout << d.f(2) << '\\n';   // prints \"f(int): 3\"\n        std::cout << d.f(2.3) << '\\n'; // prints \"f(int): 3\"\n    }\n\n##### Example, good\n\n    class D: public B {\n    public:\n        int f(int i) override { std::cout << \"f(int): \"; return i + 1; }\n        using B::f; // exposes f(double)\n    };\n\n##### Note\n\nThis issue affects both virtual and non-virtual member functions\n\nFor variadic bases, C++17 introduced a variadic form of the using-declaration,\n\n    template<class... Ts>\n    struct Overloader : Ts... {\n        using Ts::operator()...; // exposes operator() from every base\n    };\n\n##### Enforcement\n\nDiagnose name hiding\n\n### <a name=\"rh-final\"></a>C.139: Use `final` on classes sparingly\n\n##### Reason\n\nCapping a hierarchy with `final` classes is rarely needed for logical reasons and can be damaging to the extensibility of a hierarchy.\n\n##### Example, bad\n\n    class Widget { /* ... */ };\n\n    // nobody will ever want to improve My_widget (or so you thought)\n    class My_widget final : public Widget { /* ... */ };\n\n    class My_improved_widget : public My_widget { /* ... */ };  // error: can't do that\n\n##### Note\n\nNot every class is meant to be a base class.\nMost standard-library classes are examples of that (e.g., `std::vector` and `std::string` are not designed to be derived from).\nThis rule is about using `final` on classes with virtual functions meant to be interfaces for a class hierarchy.\n\n##### Note\n\nClaims of performance improvements from `final` should be substantiated.\nToo often, such claims are based on conjecture or experience with other languages.\n\nThere are examples where `final` can be important for both logical and performance reasons.\nOne example is a performance-critical AST hierarchy in a compiler or language analysis tool.\nNew derived classes are not added every year and only by library implementers.\nHowever, misuses are (or at least have been) far more common.\n\n##### Enforcement\n\nFlag uses of `final` on classes.\n\n\n### <a name=\"rh-virtual-default-arg\"></a>C.140: Do not provide different default arguments for a virtual function and an overrider\n\n##### Reason\n\nThat can cause confusion: An overrider does not inherit default arguments.\n\n##### Example, bad\n\n    class Base {\n    public:\n        virtual int multiply(int value, int factor = 2) = 0;\n        virtual ~Base() = default;\n    };\n\n    class Derived : public Base {\n    public:\n        int multiply(int value, int factor = 10) override;\n    };\n\n    Derived d;\n    Base& b = d;\n\n    b.multiply(10);  // these two calls will call the same function but\n    d.multiply(10);  // with different arguments and so different results\n\n##### Enforcement\n\nFlag default arguments on virtual functions if they differ between base and derived declarations.\n\n## C.hier-access: Accessing objects in a hierarchy\n\n### <a name=\"rh-poly\"></a>C.145: Access polymorphic objects through pointers and references\n\n##### Reason\n\nIf you have a class with a virtual function, you don't (in general) know which class provided the function to be used.\n\n##### Example\n\n    struct B { int a; virtual int f(); virtual ~B() = default };\n    struct D : B { int b; int f() override; };\n\n    void use(B b)\n    {\n        D d;\n        B b2 = d;   // slice\n        B b3 = b;\n    }\n\n    void use2()\n    {\n        D d;\n        use(d);   // slice\n    }\n\nBoth `d`s are sliced.\n\n##### Exception\n\nYou can safely access a named polymorphic object in the scope of its definition, just don't slice it.\n\n    void use3()\n    {\n        D d;\n        d.f();   // OK\n    }\n\n##### See also\n\n[A polymorphic class should suppress copying](#rc-copy-virtual)\n\n##### Enforcement\n\nFlag all slicing.\n\n### <a name=\"rh-dynamic_cast\"></a>C.146: Use `dynamic_cast` where class hierarchy navigation is unavoidable\n\n##### Reason\n\n`dynamic_cast` is checked at run time.\n\n##### Example\n\n    struct B {   // an interface\n        virtual void f();\n        virtual void g();\n        virtual ~B();\n    };\n\n    struct D : B {   // a wider interface\n        void f() override;\n        virtual void h();\n    };\n\n    void user(B* pb)\n    {\n        if (D* pd = dynamic_cast<D*>(pb)) {\n            // ... use D's interface ...\n        }\n        else {\n            // ... make do with B's interface ...\n        }\n    }\n\nUse of the other casts can violate type safety and cause the program to access a variable that is actually of type `X` to be accessed as if it were of an unrelated type `Z`:\n\n    void user2(B* pb)   // bad\n    {\n        D* pd = static_cast<D*>(pb);    // I know that pb really points to a D; trust me\n        // ... use D's interface ...\n    }\n\n    void user3(B* pb)    // unsafe\n    {\n        if (some_condition) {\n            D* pd = static_cast<D*>(pb);   // I know that pb really points to a D; trust me\n            // ... use D's interface ...\n        }\n        else {\n            // ... make do with B's interface ...\n        }\n    }\n\n    void f()\n    {\n        B b;\n        user(&b);   // OK\n        user2(&b);  // bad error\n        user3(&b);  // OK *if* the programmer got the some_condition check right\n    }\n\n##### Note\n\nLike other casts, `dynamic_cast` is overused.\n[Prefer virtual functions to casting](#rh-use-virtual).\nPrefer [static polymorphism](#???) to hierarchy navigation where it is possible (no run-time resolution necessary)\nand reasonably convenient.\n\n##### Note\n\nSome people use `dynamic_cast` where a `typeid` would have been more appropriate;\n`dynamic_cast` is a general \"is kind of\" operation for discovering the best interface to an object,\nwhereas `typeid` is a \"give me the exact type of this object\" operation to discover the actual type of an object.\nThe latter is an inherently simpler operation that ought to be faster.\nThe latter (`typeid`) is easily hand-crafted if necessary (e.g., if working on a system where RTTI is -- for some reason -- prohibited),\nthe former (`dynamic_cast`) is far harder to implement correctly in general.\n\nConsider:\n\n    struct B {\n        const char* name {\"B\"};\n        // if pb1->id() == pb2->id() *pb1 is the same type as *pb2\n        virtual const char* id() const { return name; }\n        // ...\n    };\n\n    struct D : B {\n        const char* name {\"D\"};\n        const char* id() const override { return name; }\n        // ...\n    };\n\n    void use()\n    {\n        B* pb1 = new B;\n        B* pb2 = new D;\n\n        cout << pb1->id(); // \"B\"\n        cout << pb2->id(); // \"D\"\n\n\n        if (pb2->id() == \"D\") {         // looks innocent\n            D* pd = static_cast<D*>(pb2);\n            // ...\n        }\n        // ...\n    }\n\nThe result of `pb2->id() == \"D\"` is actually implementation defined.\nWe added it to warn of the dangers of home-brew RTTI.\nThis code might work as expected for years, just to fail on a new machine, new compiler, or a new linker that does not unify character literals.\n\nIf you implement your own RTTI, be careful.\n\n##### Exception\n\nIf your implementation provided a really slow `dynamic_cast`, you might have to use a workaround.\nHowever, all workarounds that cannot be statically resolved involve explicit casting (typically `static_cast`) and are error-prone.\nYou will basically be crafting your own special-purpose `dynamic_cast`.\nSo, first make sure that your `dynamic_cast` really is as slow as you think it is (there are a fair number of unsupported rumors about)\nand that your use of `dynamic_cast` is really performance critical.\n\nWe are of the opinion that current implementations of `dynamic_cast` are unnecessarily slow.\nFor example, under suitable conditions, it is possible to perform a `dynamic_cast` in [fast constant time](https://www.stroustrup.com/fast_dynamic_casting.pdf).\nHowever, compatibility makes changes difficult even if all agree that an effort to optimize is worthwhile.\n\nIn very rare cases, if you have measured that the `dynamic_cast` overhead is material, you have other means to statically guarantee that a downcast will succeed (e.g., you are using CRTP carefully), and there is no virtual inheritance involved, consider tactically resorting `static_cast` with a prominent comment and disclaimer summarizing this paragraph and that human attention is needed under maintenance because the type system can't verify correctness. Even so, in our experience such \"I know what I'm doing\" situations are still a known bug source.\n\n##### Exception\n\nConsider:\n\n    template<typename B>\n    class Dx : B {\n        // ...\n    };\n\n##### Enforcement\n\n* Flag all uses of `static_cast` for downcasts, including C-style casts that perform a `static_cast`.\n* This rule is part of the [type-safety profile](#pro-type-downcast).\n\n### <a name=\"rh-ref-cast\"></a>C.147: Use `dynamic_cast` to a reference type when failure to find the required class is considered an error\n\n##### Reason\n\nCasting to a reference expresses that you intend to end up with a valid object, so the cast must succeed. `dynamic_cast` will then throw if it does not succeed.\n\n##### Example\n\n    std::string f(Base& b)\n    {\n        return dynamic_cast<Derived&>(b).to_string();\n    }\n\n##### Enforcement\n\n???\n\n### <a name=\"rh-ptr-cast\"></a>C.148: Use `dynamic_cast` to a pointer type when failure to find the required class is considered a valid alternative\n\n##### Reason\n\nThe `dynamic_cast` conversion allows to test whether a pointer is pointing at a polymorphic object that has a given class in its hierarchy. Since failure to find the class merely returns a null value, it can be tested during run time. This allows writing code that can choose alternative paths depending on the results.\n\nContrast with [C.147](#rh-ref-cast), where failure is an error, and should not be used for conditional execution.\n\n##### Example\n\nThe example below describes the `add` function of a `Shape_owner` that takes ownership of constructed `Shape` objects. The objects are also sorted into views, according to their geometric attributes.\nIn this example, `Shape` does not inherit from `Geometric_attributes`. Only its subclasses do.\n\n    void add(Shape* const item)\n    {\n      // Ownership is always taken\n      owned_shapes.emplace_back(item);\n\n      // Check the Geometric_attributes and add the shape to none/one/some/all of the views\n\n      if (auto even = dynamic_cast<Even_sided*>(item))\n      {\n        view_of_evens.emplace_back(even);\n      }\n\n      if (auto trisym = dynamic_cast<Trilaterally_symmetrical*>(item))\n      {\n        view_of_trisyms.emplace_back(trisym);\n      }\n    }\n\n##### Notes\n\nA failure to find the required class will cause `dynamic_cast` to return a null value, and de-referencing a null-valued pointer will lead to undefined behavior.\nTherefore the result of the `dynamic_cast` should always be treated as if it might contain a null value, and tested.\n\n##### Enforcement\n\n* (Complex) Unless there is a null test on the result of a `dynamic_cast` of a pointer type, warn upon dereference of the pointer.\n\n### <a name=\"rh-smart\"></a>C.149: Use `unique_ptr` or `shared_ptr` to avoid forgetting to `delete` objects created using `new`\n\n##### Reason\n\nAvoid resource leaks.\n\n##### Example\n\n    void use(int i)\n    {\n        auto p = new int {7};           // bad: initialize local pointers with new\n        auto q = make_unique<int>(9);   // ok: guarantee the release of the memory-allocated for 9\n        if (0 < i) return;              // maybe return and leak\n        delete p;                       // too late\n    }\n\n##### Enforcement\n\n* Flag initialization of a naked pointer with the result of a `new`\n* Flag `delete` of local variable\n\n### <a name=\"rh-make_unique\"></a>C.150: Use `make_unique()` to construct objects owned by `unique_ptr`s\n\nSee [R.23](#rr-make_unique)\n\n### <a name=\"rh-make_shared\"></a>C.151: Use `make_shared()` to construct objects owned by `shared_ptr`s\n\nSee [R.22](#rr-make_shared)\n\n### <a name=\"rh-array\"></a>C.152: Never assign a pointer to an array of derived class objects to a pointer to its base\n\n##### Reason\n\nSubscripting the resulting base pointer will lead to invalid object access and probably to memory corruption.\n\n##### Example\n\n    struct B { int x; };\n    struct D : B { int y; };\n\n    void use(B*);\n\n    D a[] = { {1, 2}, {3, 4}, {5, 6} };\n    B* p = a;     // bad: a decays to &a[0] which is converted to a B*\n    p[1].x = 7;   // overwrite a[0].y\n\n    use(a);       // bad: a decays to &a[0] which is converted to a B*\n\n##### Enforcement\n\n* Flag all combinations of array decay and base to derived conversions.\n* Pass an array as a `span` rather than as a pointer, and don't let the array name suffer a derived-to-base conversion before getting into the `span`\n\n\n### <a name=\"rh-use-virtual\"></a>C.153: Prefer virtual function to casting\n\n##### Reason\n\nA virtual function call is safe, whereas casting is error-prone.\nA virtual function call reaches the most derived function, whereas a cast might reach an intermediate class and therefore\ngive a wrong result (especially as a hierarchy is modified during maintenance).\n\n##### Example\n\n    ???\n\n##### Enforcement\n\nSee [C.146](#rh-dynamic_cast) and ???\n\n## <a name=\"ss-overload\"></a>C.over: Overloading and overloaded operators\n\nYou can overload ordinary functions, function templates, and operators.\nYou cannot overload function objects.\n\nOverload rule summary:\n\n* [C.160: Define operators primarily to mimic conventional usage](#ro-conventional)\n* [C.161: Use non-member functions for symmetric operators](#ro-symmetric)\n* [C.162: Overload operations that are roughly equivalent](#ro-equivalent)\n* [C.163: Overload only for operations that are roughly equivalent](#ro-equivalent-2)\n* [C.164: Avoid implicit conversion operators](#ro-conversion)\n* [C.165: Use `using` for customization points](#ro-custom)\n* [C.166: Overload unary `&` only as part of a system of smart pointers and references](#ro-address-of)\n* [C.167: Use an operator for an operation with its conventional meaning](#ro-overload)\n* [C.168: Define overloaded operators in the namespace of their operands](#ro-namespace)\n* [C.170: If you feel like overloading a lambda, use a generic lambda](#ro-lambda)\n\n### <a name=\"ro-conventional\"></a>C.160: Define operators primarily to mimic conventional usage\n\n##### Reason\n\nMinimize surprises.\n\n##### Example\n\n    class X {\n    public:\n        // ...\n        X& operator=(const X&); // member function defining assignment\n        friend bool operator==(const X&, const X&); // == needs access to representation\n                                                    // after a = b we have a == b\n        // ...\n    };\n\nHere, the conventional semantics is maintained: [Copies compare equal](#ss-copy).\n\n##### Example, bad\n\n    X operator+(X a, X b) { return a.v - b.v; }   // bad: makes + subtract\n\n##### Note\n\nNon-member operators should be either friends or defined in [the same namespace as their operands](#ro-namespace).\n[Binary operators should treat their operands equivalently](#ro-symmetric).\n\n##### Enforcement\n\nPossibly impossible.\n\n### <a name=\"ro-symmetric\"></a>C.161: Use non-member functions for symmetric operators\n\n##### Reason\n\nIf you use member functions, you need two.\nUnless you use a non-member function for (say) `==`, `a == b` and `b == a` will be subtly different.\n\n##### Example\n\n    bool operator==(Point a, Point b) { return a.x == b.x && a.y == b.y; }\n\n##### Enforcement\n\nFlag member operator functions.\n\n### <a name=\"ro-equivalent\"></a>C.162: Overload operations that are roughly equivalent\n\n##### Reason\n\nHaving different names for logically equivalent operations on different argument types is confusing, leads to encoding type information in function names, and inhibits generic programming.\n\n##### Example\n\nConsider:\n\n    void print(int a);\n    void print(int a, int base);\n    void print(const string&);\n\nThese three functions all print their arguments (appropriately). Conversely:\n\n    void print_int(int a);\n    void print_based(int a, int base);\n    void print_string(const string&);\n\nThese three functions all print their arguments (appropriately). Adding to the name just introduced verbosity and inhibits generic code.\n\n##### Enforcement\n\n???\n\n### <a name=\"ro-equivalent-2\"></a>C.163: Overload only for operations that are roughly equivalent\n\n##### Reason\n\nHaving the same name for logically different functions is confusing and leads to errors when using generic programming.\n\n##### Example\n\nConsider:\n\n    void open_gate(Gate& g);   // remove obstacle from garage exit lane\n    void fopen(const char* name, const char* mode);   // open file\n\nThe two operations are fundamentally different (and unrelated) so it is good that their names differ. Conversely:\n\n    void open(Gate& g);   // remove obstacle from garage exit lane\n    void open(const char* name, const char* mode =\"r\");   // open file\n\nThe two operations are still fundamentally different (and unrelated) but the names have been reduced to their (common) minimum, opening opportunities for confusion.\nFortunately, the type system will catch many such mistakes.\n\n##### Note\n\nBe particularly careful about common and popular names, such as `open`, `move`, `+`, and `==`.\n\n##### Enforcement\n\n???\n\n### <a name=\"ro-conversion\"></a>C.164: Avoid implicit conversion operators\n\n##### Reason\n\nImplicit conversions can be essential (e.g., `double` to `int`) but often cause surprises (e.g., `String` to C-style string).\n\n##### Note\n\nPrefer explicitly named conversions until a serious need is demonstrated.\nBy \"serious need\" we mean a reason that is fundamental in the application domain (such as an integer to complex number conversion)\nand frequently needed. Do not introduce implicit conversions (through conversion operators or non-`explicit` constructors)\njust to gain a minor convenience.\n\n##### Example\n\n    struct S1 {\n        string s;\n        // ...\n        operator char*() { return s.data(); }  // BAD, likely to cause surprises\n    };\n\n    struct S2 {\n        string s;\n        // ...\n        explicit operator char*() { return s.data(); }\n    };\n\n    void f(S1 s1, S2 s2)\n    {\n        char* x1 = s1;     // OK, but can cause surprises in many contexts\n        char* x2 = s2;     // error (and that's usually a good thing)\n        char* x3 = static_cast<char*>(s2); // we can be explicit (on your head be it)\n    }\n\nThe surprising and potentially damaging implicit conversion can occur in arbitrarily hard-to spot contexts, e.g.,\n\n    S1 ff();\n\n    char* g()\n    {\n        return ff();\n    }\n\nThe string returned by `ff()` is destroyed before the returned pointer into it can be used.\n\n##### Enforcement\n\nFlag all non-explicit conversion operators.\n\n### <a name=\"ro-custom\"></a>C.165: Use `using` for customization points\n\n##### Reason\n\nTo find function objects and functions defined in a separate namespace to \"customize\" a common function.\n\n##### Example\n\nConsider `swap`. It is a general (standard-library) function with a definition that will work for just about any type.\nHowever, it is desirable to define specific `swap()`s for specific types.\nFor example, the general `swap()` will copy the elements of two `vector`s being swapped, whereas a good specific implementation will not copy elements at all.\n\n    namespace N {\n        My_type X { /* ... */ };\n        void swap(X&, X&);   // optimized swap for N::X\n        // ...\n    }\n\n    void f1(N::X& a, N::X& b)\n    {\n        std::swap(a, b);   // probably not what we wanted: calls std::swap()\n    }\n\nThe `std::swap()` in `f1()` does exactly what we asked it to do: it calls the `swap()` in namespace `std`.\nUnfortunately, that's probably not what we wanted.\nHow do we get `N::X` considered?\n\n    void f2(N::X& a, N::X& b)\n    {\n        swap(a, b);   // calls N::swap\n    }\n\nBut that might not be what we wanted for generic code.\nThere, we typically want the specific function if it exists and the general function if not.\nThis is done by including the general function in the lookup for the function:\n\n    void f3(N::X& a, N::X& b)\n    {\n        using std::swap;  // make std::swap available\n        swap(a, b);        // calls N::swap if it exists, otherwise std::swap\n    }\n\n##### Enforcement\n\nUnlikely, except for known customization points, such as `swap`.\nThe problem is that the unqualified and qualified lookups both have uses.\n\n### <a name=\"ro-address-of\"></a>C.166: Overload unary `&` only as part of a system of smart pointers and references\n\n##### Reason\n\nThe `&` operator is fundamental in C++.\nMany parts of the C++ semantics assume its default meaning.\n\n##### Example\n\n    class Ptr { // a somewhat smart pointer\n        Ptr(X* pp) : p(pp) { /* check */ }\n        X* operator->() { /* check */ return p; }\n        X operator[](int i);\n        X operator*();\n    private:\n        T* p;\n    };\n\n    class X {\n        Ptr operator&() { return Ptr{this}; }\n        // ...\n    };\n\n##### Note\n\nIf you \"mess with\" operator `&` be sure that its definition has matching meanings for `->`, `[]`, `*`, and `.` on the result type.\nNote that operator `.` currently cannot be overloaded so a perfect system is impossible.\nWe hope to remedy that: [Operator Dot (R2)](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4477.pdf).\nNote that `std::addressof()` always yields a built-in pointer.\n\n##### Enforcement\n\nTricky. Warn if `&` is user-defined without also defining `->` for the result type.\n\n### <a name=\"ro-overload\"></a>C.167: Use an operator for an operation with its conventional meaning\n\n##### Reason\n\nReadability. Convention. Reusability. Support for generic code\n\n##### Example\n\n    void cout_my_class(const My_class& c) // confusing, not conventional, not generic\n    {\n        std::cout << /* class members here */;\n    }\n\n    std::ostream& operator<<(std::ostream& os, const my_class& c) // OK\n    {\n        return os << /* class members here */;\n    }\n\nBy itself, `cout_my_class` would be OK, but it is not usable/composable with code that relies on the `<<` convention for output:\n\n    My_class var { /* ... */ };\n    // ...\n    cout << \"var = \" << var << '\\n';\n\n##### Note\n\nThere are strong and vigorous conventions for the meaning of most operators, such as\n\n* comparisons (`==`, `!=`, `<`, `<=`, `>`, `>=`, and `<=>`),\n* arithmetic operations (`+`, `-`, `*`, `/`, and `%`)\n* access operations (`.`, `->`, unary `*`, and `[]`)\n* assignment (`=`)\n\nDon't define those unconventionally and don't invent your own names for them.\n\n##### Enforcement\n\nTricky. Requires semantic insight.\n\n### <a name=\"ro-namespace\"></a>C.168: Define overloaded operators in the namespace of their operands\n\n##### Reason\n\nReadability.\nAbility for find operators using ADL.\nAvoiding inconsistent definition in different namespaces\n\n##### Example\n\n    struct S { };\n    S operator+(S, S);   // OK: in the same namespace as S, and even next to S\n    S s;\n\n    S r = s + s;\n\n##### Example\n\n    namespace N {\n        struct S { };\n        S operator+(S, S);   // OK: in the same namespace as S, and even next to S\n    }\n\n    N::S s;\n\n    S r = s + s;  // finds N::operator+() by ADL\n\n##### Example, bad\n\n    struct S { };\n    S s;\n\n    namespace N {\n        bool operator!(S a) { return true; }\n        bool not_s = !s;\n    }\n\n    namespace M {\n        bool operator!(S a) { return false; }\n        bool not_s = !s;\n    }\n\nHere, the meaning of `!s` differs in `N` and `M`.\nThis can be most confusing.\nRemove the definition of `namespace M` and the confusion is replaced by an opportunity to make the mistake.\n\n##### Note\n\nIf a binary operator is defined for two types that are defined in different namespaces, you cannot follow this rule.\nFor example:\n\n    Vec::Vector operator*(const Vec::Vector&, const Mat::Matrix&);\n\nThis might be something best avoided.\n\n##### See also\n\nThis is a special case of the rule that [helper functions should be defined in the same namespace as their class](#rc-helper).\n\n##### Enforcement\n\n* Flag operator definitions that are not in the namespace of their operands\n\n### <a name=\"ro-lambda\"></a>C.170: If you feel like overloading a lambda, use a generic lambda\n\n##### Reason\n\nYou cannot overload by defining two different lambdas with the same name.\n\n##### Example\n\n    void f(int);\n    void f(double);\n    auto f = [](char);   // error: cannot overload variable and function\n\n    auto g = [](int) { /* ... */ };\n    auto g = [](double) { /* ... */ };   // error: cannot overload variables\n\n    auto h = [](auto) { /* ... */ };   // OK\n\n##### Enforcement\n\nThe compiler catches the attempt to overload a lambda.\n\n## <a name=\"ss-union\"></a>C.union: Unions\n\nA `union` is a `struct` where all members start at the same address so that it can hold only one member at a time.\nA `union` does not keep track of which member is stored so the programmer has to get it right;\nthis is inherently error-prone, but there are ways to compensate.\n\nA type that is a `union` plus an indicator of which member is currently held is called a *tagged union*, a *discriminated union*, or a *variant*.\n\nUnion rule summary:\n\n* [C.180: Use `union`s to save Memory](#ru-union)\n* [C.181: Avoid \"naked\" `union`s](#ru-naked)\n* [C.182: Use anonymous `union`s to implement tagged unions](#ru-anonymous)\n* [C.183: Don't use a `union` for type punning](#ru-pun)\n* ???\n\n### <a name=\"ru-union\"></a>C.180: Use `union`s to save memory\n\n##### Reason\n\nA `union` allows a single piece of memory to be used for different types of objects at different times.\nConsequently, it can be used to save memory when we have several objects that are never used at the same time.\n\n##### Example\n\n    union Value {\n        int x;\n        double d;\n    };\n\n    Value v = { 123 };  // now v holds an int\n    cout << v.x << '\\n';    // write 123\n    v.d = 987.654;  // now v holds a double\n    cout << v.d << '\\n';    // write 987.654\n\nBut heed the warning: [Avoid \"naked\" `union`s](#ru-naked)\n\n##### Example\n\n    // Short-string optimization\n\n    constexpr size_t buffer_size = 16; // Slightly larger than the size of a pointer\n\n    class Immutable_string {\n    public:\n        Immutable_string(const char* str) :\n            size(strlen(str))\n        {\n            if (size < buffer_size)\n                strcpy_s(string_buffer, buffer_size, str);\n            else {\n                string_ptr = new char[size + 1];\n                strcpy_s(string_ptr, size + 1, str);\n            }\n        }\n\n        ~Immutable_string()\n        {\n            if (size >= buffer_size)\n                delete[] string_ptr;\n        }\n\n        const char* get_str() const\n        {\n            return (size < buffer_size) ? string_buffer : string_ptr;\n        }\n\n    private:\n        // If the string is short enough, we store the string itself\n        // instead of a pointer to the string.\n        union {\n            char* string_ptr;\n            char string_buffer[buffer_size];\n        };\n\n        const size_t size;\n    };\n\n##### Enforcement\n\n???\n\n### <a name=\"ru-naked\"></a>C.181: Avoid \"naked\" `union`s\n\n##### Reason\n\nA *naked union* is a union without an associated indicator which member (if any) it holds,\nso that the programmer has to keep track.\nNaked unions are a source of type errors.\n\n##### Example, bad\n\n    union Value {\n        int x;\n        double d;\n    };\n\n    Value v;\n    v.d = 987.654;  // v holds a double\n\nSo far, so good, but we can easily misuse the `union`:\n\n    cout << v.x << '\\n';    // BAD, undefined behavior: v holds a double, but we read it as an int\n\nNote that the type error happened without any explicit cast.\nWhen we tested that program the last value printed was `1683627180` which is the integer value for the bit pattern for `987.654`.\nWhat we have here is an \"invisible\" type error that happens to give a result that could easily look innocent.\n\nAnd, talking about \"invisible\", this code produced no output:\n\n    v.x = 123;\n    cout << v.d << '\\n';    // BAD: undefined behavior\n\n##### Alternative\n\nWrap a `union` in a class together with a type field.\n\nThe C++17 `variant` type (found in `<variant>`) does that for you:\n\n    variant<int, double> v;\n    v = 123;        // v holds an int\n    int x = get<int>(v);\n    v = 123.456;    // v holds a double\n    double w = get<double>(v);\n\n##### Enforcement\n\n???\n\n### <a name=\"ru-anonymous\"></a>C.182: Use anonymous `union`s to implement tagged unions\n\n##### Reason\n\nA well-designed tagged union is type safe.\nAn *anonymous* union simplifies the definition of a class with a (tag, union) pair.\n\n##### Example\n\nThis example is mostly borrowed from TC++PL4, pp. 216--218.\nYou can look there for an explanation.\n\nThe code is somewhat elaborate.\nHandling a type with user-defined assignment and destructor is tricky.\nSaving programmers from having to write such code is one reason for including `variant` in the standard.\n\n    class Value { // two alternative representations represented as a union\n    private:\n        enum class Tag { number, text };\n        Tag type; // discriminant\n\n        union { // representation (note: anonymous union)\n            int i;\n            string s; // string has default constructor, copy operations, and destructor\n        };\n    public:\n        struct Bad_entry { }; // used for exceptions\n\n        ~Value();\n        Value& operator=(const Value&);   // necessary because of the string variant\n        Value(const Value&);\n        // ...\n        int number() const;\n        string text() const;\n\n        void set_number(int n);\n        void set_text(const string&);\n        // ...\n    };\n\n    int Value::number() const\n    {\n        if (type != Tag::number) throw Bad_entry{};\n        return i;\n    }\n\n    string Value::text() const\n    {\n        if (type != Tag::text) throw Bad_entry{};\n        return s;\n    }\n\n    void Value::set_number(int n)\n    {\n        if (type == Tag::text) {\n            s.~string();      // explicitly destroy string\n            type = Tag::number;\n        }\n        i = n;\n    }\n\n    void Value::set_text(const string& ss)\n    {\n        if (type == Tag::text)\n            s = ss;\n        else {\n            new(&s) string{ss};   // placement new: explicitly construct string\n            type = Tag::text;\n        }\n    }\n\n    Value& Value::operator=(const Value& e)   // necessary because of the string variant\n    {\n        if (type == Tag::text && e.type == Tag::text) {\n            s = e.s;    // usual string assignment\n            return *this;\n        }\n\n        if (type == Tag::text) s.~string(); // explicit destroy\n\n        switch (e.type) {\n        case Tag::number:\n            i = e.i;\n            break;\n        case Tag::text:\n            new(&s) string(e.s);   // placement new: explicit construct\n        }\n\n        type = e.type;\n        return *this;\n    }\n\n    Value::~Value()\n    {\n        if (type == Tag::text) s.~string(); // explicit destroy\n    }\n\n##### Enforcement\n\n???\n\n### <a name=\"ru-pun\"></a>C.183: Don't use a `union` for type punning\n\n##### Reason\n\nIt is undefined behavior to read a `union` member with a different type from the one with which it was written.\nSuch punning is invisible, or at least harder to spot than using a named cast.\nType punning using a `union` is a source of errors.\n\n##### Example, bad\n\n    union Pun {\n        int x;\n        unsigned char c[sizeof(int)];\n    };\n\nThe idea of `Pun` is to be able to look at the character representation of an `int`.\n\n    void bad(Pun& u)\n    {\n        u.x = 'x';\n        cout << u.c[0] << '\\n';     // undefined behavior\n    }\n\nIf you wanted to see the bytes of an `int`, use a (named) cast:\n\n    void if_you_must_pun(int& x)\n    {\n        auto p = reinterpret_cast<std::byte*>(&x);\n        cout << to_integer<unsigned>(p[0]) << '\\n'; // OK; better\n        // ...\n    }\n\nAccessing the result of a `reinterpret_cast` from the object's declared type to `char*`, `unsigned char*`, or `std::byte*` is defined behavior. (Using `reinterpret_cast` is discouraged,\nbut at least we can see that something tricky is going on.)\n\n##### Note\n\nUnfortunately, `union`s are commonly used for type punning.\nWe don't consider \"sometimes, it works as expected\" a conclusive argument.\n\nModern C++ introduced `std::byte` (C++17) and `std::bit_cast` (C++20) to facilitate operations on raw object representations.\nUse `reinterpret_cast` along with `std::byte` instead of `unsigned char` or `char` for these operations.\n\n\n##### Enforcement\n\n???\n\n\n\n# <a name=\"s-enum\"></a>Enum: Enumerations\n\nEnumerations are used to define sets of integer values and for defining types for such sets of values.\nThere are two kinds of enumerations, \"plain\" `enum`s and `class enum`s.\n\nEnumeration rule summary:\n\n* [Enum.1: Prefer enumerations over macros](#renum-macro)\n* [Enum.2: Use enumerations to represent sets of related named constants](#renum-set)\n* [Enum.3: Prefer `enum class`es over \"plain\" `enum`s](#renum-class)\n* [Enum.4: Define operations on enumerations for safe and simple use](#renum-oper)\n* [Enum.5: Don't use `ALL_CAPS` for enumerators](#renum-caps)\n* [Enum.6: Avoid unnamed enumerations](#renum-unnamed)\n* [Enum.7: Specify the underlying type of an enumeration only when necessary](#renum-underlying)\n* [Enum.8: Specify enumerator values only when necessary](#renum-value)\n\n### <a name=\"renum-macro\"></a>Enum.1: Prefer enumerations over macros\n\n##### Reason\n\nMacros do not obey scope and type rules. Also, macro names are removed during preprocessing and so usually don't appear in tools like debuggers.\n\n##### Example\n\nFirst some bad old code:\n\n    // webcolors.h (third party header)\n    #define RED   0xFF0000\n    #define GREEN 0x00FF00\n    #define BLUE  0x0000FF\n\n    // productinfo.h\n    // The following define product subtypes based on color\n    #define RED    0\n    #define PURPLE 1\n    #define BLUE   2\n\n    int webby = BLUE;   // webby == 2; probably not what was desired\n\nInstead use an `enum`:\n\n    enum class Web_color { red = 0xFF0000, green = 0x00FF00, blue = 0x0000FF };\n    enum class Product_info { red = 0, purple = 1, blue = 2 };\n\n    int webby = blue;   // error: be specific\n    Web_color webby = Web_color::blue;\n\nWe used an `enum class` to avoid name clashes.\n\n##### Note\n\nAlso consider `constexpr` and `const inline` variables.\n\n##### Enforcement\n\nFlag macros that define integer values. Use `enum` or `const inline` or another non-macro alternative instead.\n\n\n### <a name=\"renum-set\"></a>Enum.2: Use enumerations to represent sets of related named constants\n\n##### Reason\n\nAn enumeration shows the enumerators to be related and can be a named type.\n\n\n\n##### Example\n\n    enum class Web_color { red = 0xFF0000, green = 0x00FF00, blue = 0x0000FF };\n\n\n##### Note\n\nSwitching on an enumeration is common and the compiler can warn against unusual patterns of case labels. For example:\n\n    enum class Product_info { red = 0, purple = 1, blue = 2 };\n\n    void print(Product_info inf)\n    {\n        switch (inf) {\n        case Product_info::red: cout << \"red\"; break;\n        case Product_info::purple: cout << \"purple\"; break;\n        }\n    }\n\nSuch off-by-one `switch`-statements are often the results of an added enumerator and insufficient testing.\n\n##### Enforcement\n\n* Flag `switch`-statements where the `case`s cover most but not all enumerators of an enumeration.\n* Flag `switch`-statements where the `case`s cover a few enumerators of an enumeration, but there is no `default`.\n\n\n### <a name=\"renum-class\"></a>Enum.3: Prefer class enums over \"plain\" enums\n\n##### Reason\n\nTo minimize surprises: traditional enums convert to int too readily.\n\n##### Example\n\n    void Print_color(int color);\n\n    enum Web_color { red = 0xFF0000, green = 0x00FF00, blue = 0x0000FF };\n    enum Product_info { red = 0, purple = 1, blue = 2 };\n\n    Web_color webby = Web_color::blue;\n\n    // Clearly at least one of these calls is buggy.\n    Print_color(webby);\n    Print_color(Product_info::blue);\n\nInstead use an `enum class`:\n\n    void Print_color(int color);\n\n    enum class Web_color { red = 0xFF0000, green = 0x00FF00, blue = 0x0000FF };\n    enum class Product_info { red = 0, purple = 1, blue = 2 };\n\n    Web_color webby = Web_color::blue;\n    Print_color(webby);  // Error: cannot convert Web_color to int.\n    Print_color(Product_info::red);  // Error: cannot convert Product_info to int.\n\n##### Enforcement\n\n(Simple) Warn on any non-class `enum` definition.\n\n### <a name=\"renum-oper\"></a>Enum.4: Define operations on enumerations for safe and simple use\n\n##### Reason\n\nConvenience of use and avoidance of errors.\n\n##### Example\n\n    enum class Day { mon, tue, wed, thu, fri, sat, sun };\n\n    Day& operator++(Day& d)\n    {\n        return d = (d == Day::sun) ? Day::mon : static_cast<Day>(static_cast<int>(d)+1);\n    }\n\n    Day today = Day::sat;\n    Day tomorrow = ++today;\n\nThe use of a `static_cast` is not pretty, but\n\n    Day& operator++(Day& d)\n    {\n        return d = (d == Day::sun) ? Day::mon : Day{++d};    // error\n    }\n\nis an infinite recursion, and writing it without a cast, using a `switch` on all cases is long-winded.\n\n\n##### Enforcement\n\nFlag repeated expressions cast back into an enumeration.\n\n\n### <a name=\"renum-caps\"></a>Enum.5: Don't use `ALL_CAPS` for enumerators\n\n##### Reason\n\nAvoid clashes with macros.\n\n##### Example, bad\n\n     // webcolors.h (third party header)\n    #define RED   0xFF0000\n    #define GREEN 0x00FF00\n    #define BLUE  0x0000FF\n\n    // productinfo.h\n    // The following define product subtypes based on color\n\n    enum class Product_info { RED, PURPLE, BLUE };   // syntax error\n\n##### Enforcement\n\nFlag ALL_CAPS enumerators.\n\n### <a name=\"renum-unnamed\"></a>Enum.6: Avoid unnamed enumerations\n\n##### Reason\n\nIf you can't name an enumeration, the values are not related\n\n##### Example, bad\n\n    enum { red = 0xFF0000, scale = 4, is_signed = 1 };\n\nSuch code is not uncommon in code written before there were convenient alternative ways of specifying integer constants.\n\n##### Alternative\n\nUse `constexpr` values instead. For example:\n\n    constexpr int red = 0xFF0000;\n    constexpr short scale = 4;\n    constexpr bool is_signed = true;\n\n##### Enforcement\n\nFlag unnamed enumerations.\n\n\n### <a name=\"renum-underlying\"></a>Enum.7: Specify the underlying type of an enumeration only when necessary\n\n##### Reason\n\nThe default is the easiest to read and write.\n`int` is the default integer type.\n`int` is compatible with C `enum`s.\n\n##### Example\n\n    enum class Direction : char { n, s, e, w,\n                                  ne, nw, se, sw };  // underlying type saves space\n\n    enum class Web_color : int32_t { red   = 0xFF0000,\n                                     green = 0x00FF00,\n                                     blue  = 0x0000FF };  // underlying type is redundant\n\n##### Note\n\nSpecifying the underlying type is necessary to forward-declare an enum or enum class:\n\n    enum Flags : char;\n\n    void f(Flags);\n\n    // ....\n\n    enum Flags : char { /* ... */ };\n\nor to ensure that values of that type have a specified bit-precision:\n\n    enum Bitboard : uint64_t { /* ... */ };\n\n##### Enforcement\n\n????\n\n\n### <a name=\"renum-value\"></a>Enum.8: Specify enumerator values only when necessary\n\n##### Reason\n\nIt's the simplest.\nIt avoids duplicate enumerator values.\nThe default gives a consecutive set of values that is good for `switch`-statement implementations.\n\n##### Example\n\n    enum class Col1 { red, yellow, blue };\n    enum class Col2 { red = 1, yellow = 2, blue = 2 }; // typo\n    enum class Month { jan = 1, feb, mar, apr, may, jun,\n                       jul, august, sep, oct, nov, dec }; // starting with 1 is conventional\n    enum class Base_flag { dec = 1, oct = dec << 1, hex = dec << 2 }; // set of bits\n\nSpecifying values is necessary to match conventional values (e.g., `Month`)\nand where consecutive values are undesirable (e.g., to get separate bits as in `Base_flag`).\n\n##### Enforcement\n\n* Flag duplicate enumerator values\n* Flag explicitly specified all-consecutive enumerator values\n\n\n# <a name=\"s-resource\"></a>R: Resource management\n\nThis section contains rules related to resources.\nA resource is anything that must be acquired and (explicitly or implicitly) released, such as memory, file handles, sockets, and locks.\nThe reason it must be released is typically that it can be in short supply, so even delayed release might do harm.\nThe fundamental aim is to ensure that we don't leak any resources and that we don't hold a resource longer than we need to.\nAn entity that is responsible for releasing a resource is called an owner.\n\nThere are a few cases where leaks can be acceptable or even optimal:\nIf you are writing a program that simply produces an output based on an input and the amount of memory needed is proportional to the size of the input, the optimal strategy (for performance and ease of programming) is sometimes simply never to delete anything.\nIf you have enough memory to handle your largest input, leak away, but be sure to give a good error message if you are wrong.\nHere, we ignore such cases.\n\n* Resource management rule summary:\n\n  * [R.1: Manage resources automatically using resource handles and RAII (Resource Acquisition Is Initialization)](#rr-raii)\n  * [R.2: In interfaces, use raw pointers to denote individual objects (only)](#rr-use-ptr)\n  * [R.3: A raw pointer (a `T*`) is non-owning](#rr-ptr)\n  * [R.4: A raw reference (a `T&`) is non-owning](#rr-ref)\n  * [R.5: Prefer scoped objects, don't heap-allocate unnecessarily](#rr-scoped)\n  * [R.6: Avoid non-`const` global variables](#rr-global)\n\n* Allocation and deallocation rule summary:\n\n  * [R.10: Avoid `malloc()` and `free()`](#rr-mallocfree)\n  * [R.11: Avoid calling `new` and `delete` explicitly](#rr-newdelete)\n  * [R.12: Immediately give the result of an explicit resource allocation to a manager object](#rr-immediate-alloc)\n  * [R.13: Perform at most one explicit resource allocation in a single expression statement](#rr-single-alloc)\n  * [R.14: Avoid `[]` parameters, prefer `span`](#rr-ap)\n  * [R.15: Always overload matched allocation/deallocation pairs](#rr-pair)\n\n* <a name=\"rr-summary-smartptrs\"></a>Smart pointer rule summary:\n\n  * [R.20: Use `unique_ptr` or `shared_ptr` to represent ownership](#rr-owner)\n  * [R.21: Prefer `unique_ptr` over `shared_ptr` unless you need to share ownership](#rr-unique)\n  * [R.22: Use `make_shared()` to make `shared_ptr`s](#rr-make_shared)\n  * [R.23: Use `make_unique()` to make `unique_ptr`s](#rr-make_unique)\n  * [R.24: Use `std::weak_ptr` to break cycles of `shared_ptr`s](#rr-weak_ptr)\n  * [R.30: Take smart pointers as parameters only to explicitly express lifetime semantics](#rr-smartptrparam)\n  * [R.31: If you have non-`std` smart pointers, follow the basic pattern from `std`](#rr-smart)\n  * [R.32: Take a `unique_ptr<widget>` parameter to express that a function assumes ownership of a `widget`](#rr-uniqueptrparam)\n  * [R.33: Take a `unique_ptr<widget>&` parameter to express that a function reseats the `widget`](#rr-reseat)\n  * [R.34: Take a `shared_ptr<widget>` parameter to express shared ownership](#rr-sharedptrparam-owner)\n  * [R.35: Take a `shared_ptr<widget>&` parameter to express that a function might reseat the shared pointer](#rr-sharedptrparam)\n  * [R.36: Take a `const shared_ptr<widget>&` parameter to express that it might retain a reference count to the object ???](#rr-sharedptrparam-const)\n  * [R.37: Do not pass a pointer or reference obtained from an aliased smart pointer](#rr-smartptrget)\n\n### <a name=\"rr-raii\"></a>R.1: Manage resources automatically using resource handles and RAII (Resource Acquisition Is Initialization)\n\n##### Reason\n\nTo avoid leaks and the complexity of manual resource management.\nC++'s language-enforced constructor/destructor symmetry mirrors the symmetry inherent in resource acquire/release function pairs such as `fopen`/`fclose`, `lock`/`unlock`, and `new`/`delete`.\nWhenever you deal with a resource that needs paired acquire/release function calls, encapsulate that resource in an object that enforces pairing for you -- acquire the resource in its constructor, and release it in its destructor.\n\n##### Example, bad\n\nConsider:\n\n    void send(X* x, string_view destination)\n    {\n        auto port = open_port(destination);\n        my_mutex.lock();\n        // ...\n        send(port, x);\n        // ...\n        my_mutex.unlock();\n        close_port(port);\n        delete x;\n    }\n\nIn this code, you have to remember to `unlock`, `close_port`, and `delete` on all paths, and do each exactly once.\nFurther, if any of the code marked `...` throws an exception, then `x` is leaked and `my_mutex` remains locked.\n\n##### Example\n\nConsider:\n\n    void send(unique_ptr<X> x, string_view destination)  // x owns the X\n    {\n        Port port{destination};            // port owns the PortHandle\n        lock_guard<mutex> guard{my_mutex}; // guard owns the lock\n        // ...\n        send(port, x);\n        // ...\n    } // automatically unlocks my_mutex and deletes the pointer in x\n\nNow all resource cleanup is automatic, performed once on all paths whether or not there is an exception. As a bonus, the function now advertises that it takes over ownership of the pointer.\n\nWhat is `Port`? A handy wrapper that encapsulates the resource:\n\n    class Port {\n        PortHandle port;\n    public:\n        Port(string_view destination) : port{open_port(destination)} { }\n        ~Port() { close_port(port); }\n        operator PortHandle() { return port; }\n\n        // port handles can't usually be cloned, so disable copying and assignment if necessary\n        Port(const Port&) = delete;\n        Port& operator=(const Port&) = delete;\n    };\n\n##### Note\n\nWhere a resource is \"ill-behaved\" in that it isn't represented as a class with a destructor, wrap it in a class or use [`finally`](#re-finally)\n\n**See also**: [RAII](#re-raii)\n\n### <a name=\"rr-use-ptr\"></a>R.2: In interfaces, use raw pointers to denote individual objects (only)\n\n##### Reason\n\nArrays are best represented by a container type (e.g., `vector` (owning)) or a `span` (non-owning).\nSuch containers and views hold sufficient information to do range checking.\n\n##### Example, bad\n\n    void f(int* p, int n)   // n is the number of elements in p[]\n    {\n        // ...\n        p[2] = 7;   // bad: subscript raw pointer\n        // ...\n    }\n\nThe compiler does not read comments, and without reading other code you do not know whether `p` really points to `n` elements.\nUse a `span` instead.\n\n##### Example\n\n    void g(int* p, int fmt)   // print *p using format #fmt\n    {\n        // ... uses *p and p[0] only ...\n    }\n\n##### Exception\n\nC-style strings are passed as single pointers to a zero-terminated sequence of characters.\nUse `zstring` rather than `char*` to indicate that you rely on that convention.\n\n##### Note\n\nMany current uses of pointers to a single element could be references.\nHowever, where `nullptr` is a possible value, a reference might not be a reasonable alternative.\n\n##### Enforcement\n\n* Flag pointer arithmetic (including `++`) on a pointer that is not part of a container, view, or iterator.\n  This rule would generate a huge number of false positives if applied to an older code base.\n* Flag array names passed as simple pointers\n\n### <a name=\"rr-ptr\"></a>R.3: A raw pointer (a `T*`) is non-owning\n\n##### Reason\n\nThere is nothing (in the C++ standard or in most code) to say otherwise and most raw pointers are non-owning.\nWe want owning pointers identified so that we can reliably and efficiently delete the objects pointed to by owning pointers.\n\n##### Example\n\n    void f()\n    {\n        int* p1 = new int{7};           // bad: raw owning pointer\n        auto p2 = make_unique<int>(7);  // OK: the int is owned by a unique pointer\n        // ...\n    }\n\nThe `unique_ptr` protects against leaks by guaranteeing the deletion of its object (even in the presence of exceptions). The `T*` does not.\n\n##### Example\n\n    template<typename T>\n    class X {\n    public:\n        T* p;   // bad: it is unclear whether p is owning or not\n        T* q;   // bad: it is unclear whether q is owning or not\n        // ...\n    };\n\nWe can fix that problem by making ownership explicit:\n\n    template<typename T>\n    class X2 {\n    public:\n        owner<T*> p;  // OK: p is owning\n        T* q;         // OK: q is not owning\n        // ...\n    };\n\n##### Exception\n\nA major class of exception is legacy code, especially code that must remain compilable as C or interface with C and C-style C++ through ABIs.\nThe fact that there are billions of lines of code that violate this rule against owning `T*`s cannot be ignored.\nWe'd love to see program transformation tools turning 20-year-old \"legacy\" code into shiny modern code,\nwe encourage the development, deployment and use of such tools,\nwe hope the guidelines will help the development of such tools,\nand we even contributed (and contribute) to the research and development in this area.\nHowever, it will take time: \"legacy code\" is generated faster than we can renovate old code, and so it will be for a few years.\n\nThis code cannot all be rewritten (even assuming good code transformation software), especially not soon.\nThis problem cannot be solved (at scale) by transforming all owning pointers to `unique_ptr`s and `shared_ptr`s,\npartly because we need/use owning \"raw pointers\" as well as simple pointers in the implementation of our fundamental resource handles.\nFor example, common `vector` implementations have one owning pointer and two non-owning pointers.\nMany ABIs (and essentially all interfaces to C code) use `T*`s, some of them owning.\nSome interfaces cannot be simply annotated with `owner` because they need to remain compilable as C\n(although this would be a rare good use for a macro, that expands to `owner` in C++ mode only).\n\n##### Note\n\n`owner<T*>` has no default semantics beyond `T*`. It can be used without changing any code using it and without affecting ABIs.\nIt is simply an indicator to programmers and analysis tools.\nFor example, if an `owner<T*>` is a member of a class, that class better have a destructor that `delete`s it.\n\n##### Example, bad\n\nReturning a (raw) pointer imposes a lifetime management uncertainty on the caller; that is, who deletes the pointed-to object?\n\n    Gadget* make_gadget(int n)\n    {\n        auto p = new Gadget{n};\n        // ...\n        return p;\n    }\n\n    void caller(int n)\n    {\n        auto p = make_gadget(n);   // remember to delete p\n        // ...\n        delete p;\n    }\n\nIn addition to suffering from the problem of [leak](#rp-leak), this adds a spurious allocation and deallocation operation, and is needlessly verbose. If Gadget is cheap to move out of a function (i.e., is small or has an efficient move operation), just return it \"by value\" (see [\"out\" return values](#rf-out)):\n\n    Gadget make_gadget(int n)\n    {\n        Gadget g{n};\n        // ...\n        return g;\n    }\n\n##### Note\n\nThis rule applies to factory functions.\n\n##### Note\n\nIf pointer semantics are required (e.g., because the return type needs to refer to a base class of a class hierarchy (an interface)), return a \"smart pointer.\"\n\n##### Enforcement\n\n* (Simple) Warn on `delete` of a raw pointer that is not an `owner<T>`.\n* (Moderate) Warn on failure to either `reset` or explicitly `delete` an `owner<T>` pointer on every code path.\n* (Simple) Warn if the return value of `new` is assigned to a raw pointer.\n* (Simple) Warn if a function returns an object that was allocated within the function but has a move constructor.\n  Suggest considering returning it by value instead.\n\n### <a name=\"rr-ref\"></a>R.4: A raw reference (a `T&`) is non-owning\n\n##### Reason\n\nThere is nothing (in the C++ standard or in most code) to say otherwise and most raw references are non-owning.\nWe want owners identified so that we can reliably and efficiently delete the objects pointed to by owning pointers.\n\n##### Example\n\n    void f()\n    {\n        int& r = *new int{7};  // bad: raw owning reference\n        // ...\n        delete &r;             // bad: violated the rule against deleting raw pointers\n    }\n\n**See also**: [The raw pointer rule](#rr-ptr)\n\n##### Enforcement\n\nSee [the raw pointer rule](#rr-ptr)\n\n### <a name=\"rr-scoped\"></a>R.5: Prefer scoped objects, don't heap-allocate unnecessarily\n\n##### Reason\n\nA scoped object is a local object, a global object, or a member.\nThis implies that there is no separate allocation and deallocation cost in excess of that already used for the containing scope or object.\nThe members of a scoped object are themselves scoped and the scoped object's constructor and destructor manage the members' lifetimes.\n\n##### Example\n\nThe following example is inefficient (because it has unnecessary allocation and deallocation), vulnerable to exception throws and returns in the `...` part (leading to leaks), and verbose:\n\n    void f(int n)\n    {\n        auto p = new Gadget{n};\n        // ...\n        delete p;\n    }\n\nInstead, use a local variable:\n\n    void f(int n)\n    {\n        Gadget g{n};\n        // ...\n    }\n\n##### Enforcement\n\n* (Moderate) Warn if an object is allocated and then deallocated on all paths within a function. Suggest it should be a local stack object instead.\n* (Simple) Warn if a local `Unique_pointer` or `Shared_pointer` that is not moved, copied, reassigned or `reset` before its lifetime ends is not declared `const`.\nException: Do not produce such a warning on a local `Unique_pointer` to an unbounded array. (See below.)\n\n##### Exception\n\nIf your stack space is limited, it is OK to create a local `const unique_ptr<BigObject>` to store the object on the heap instead of the stack.\n\n### <a name=\"rr-global\"></a>R.6: Avoid non-`const` global variables\n\nSee [I.2](#ri-global)\n\n## <a name=\"ss-alloc\"></a>R.alloc: Allocation and deallocation\n\n### <a name=\"rr-mallocfree\"></a>R.10: Avoid `malloc()` and `free()`\n\n##### Reason\n\n `malloc()` and `free()` do not support construction and destruction, and do not mix well with `new` and `delete`.\n\n##### Example\n\n    class Record {\n        int id;\n        string name;\n        // ...\n    };\n\n    void use()\n    {\n        // p1 might be nullptr\n        // *p1 is not initialized; in particular,\n        // that string isn't a string, but a string-sized bag of bits\n        Record* p1 = static_cast<Record*>(malloc(sizeof(Record)));\n\n        auto p2 = new Record;\n\n        // unless an exception is thrown, *p2 is default initialized\n        auto p3 = new(nothrow) Record;\n        // p3 might be nullptr; if not, *p3 is default initialized\n\n        // ...\n\n        delete p1;    // error: cannot delete object allocated by malloc()\n        free(p2);    // error: cannot free() object allocated by new\n    }\n\nIn some implementations that `delete` and that `free()` might work, or maybe they will cause run-time errors.\n\n##### Exception\n\nThere are applications and sections of code where exceptions are not acceptable.\nSome of the best such examples are in life-critical hard-real-time code.\nBeware that many bans on exception use are based on superstition (bad)\nor by concerns for older code bases with unsystematic resource management (unfortunately, but sometimes necessary).\nIn such cases, consider the `nothrow` versions of `new`.\n\n##### Enforcement\n\nFlag explicit use of `malloc` and `free`.\n\n### <a name=\"rr-newdelete\"></a>R.11: Avoid calling `new` and `delete` explicitly\n\n##### Reason\n\nThe pointer returned by `new` should belong to a resource handle (that can call `delete`).\nIf the pointer returned by `new` is assigned to a plain/naked pointer, the object can be leaked.\n\n##### Note\n\nIn a large program, a naked `delete` (that is a `delete` in application code, rather than part of code devoted to resource management)\nis a likely bug: if you have N `delete`s, how can you be certain that you don't need N+1 or N-1?\nThe bug might be latent: it might emerge only during maintenance.\nIf you have a naked `new`, you probably need a naked `delete` somewhere, so you probably have a bug.\n\n##### Enforcement\n\n(Simple) Warn on any explicit use of `new` and `delete`. Suggest using `make_unique` instead.\n\n### <a name=\"rr-immediate-alloc\"></a>R.12: Immediately give the result of an explicit resource allocation to a manager object\n\n##### Reason\n\nIf you don't, an exception or a return might lead to a leak.\n\n##### Example, bad\n\n    void func(const string& name)\n    {\n        FILE* f = fopen(name, \"r\");            // open the file\n        vector<char> buf(1024);\n        auto _ = finally([f] { fclose(f); });  // remember to close the file\n        // ...\n    }\n\nThe allocation of `buf` might fail and leak the file handle.\n\n##### Example\n\n    void func(const string& name)\n    {\n        ifstream f{name};   // open the file\n        vector<char> buf(1024);\n        // ...\n    }\n\nThe use of the file handle (in `ifstream`) is simple, efficient, and safe.\n\n##### Enforcement\n\n* Flag explicit allocations used to initialize pointers (problem: how many direct resource allocations can we recognize?)\n\n### <a name=\"rr-single-alloc\"></a>R.13: Perform at most one explicit resource allocation in a single expression statement\n\n##### Reason\n\nIf you perform two explicit resource allocations in one statement, you could leak resources because the order of evaluation of many subexpressions, including function arguments, is unspecified.\n\n##### Example\n\n    void fun(shared_ptr<Widget> sp1, shared_ptr<Widget> sp2);\n\nThis `fun` can be called like this:\n\n    // BAD: potential leak\n    fun(shared_ptr<Widget>(new Widget(a, b)), shared_ptr<Widget>(new Widget(c, d)));\n\nThis is exception-unsafe because the compiler might reorder the two expressions building the function's two arguments.\nIn particular, the compiler can interleave execution of the two expressions:\nMemory allocation (by calling `operator new`) could be done first for both objects, followed by attempts to call the two `Widget` constructors.\nIf one of the constructor calls throws an exception, then the other object's memory will never be released!\n\nThis subtle problem has a simple solution: Never perform more than one explicit resource allocation in a single expression statement.\nFor example:\n\n    shared_ptr<Widget> sp1(new Widget(a, b)); // Better, but messy\n    fun(sp1, new Widget(c, d));\n\nThe best solution is to avoid explicit allocation entirely, use factory functions that return owning objects:\n\n    fun(make_shared<Widget>(a, b), make_shared<Widget>(c, d)); // Best\n\nWrite your own factory wrapper if there is not one already.\n\n##### Enforcement\n\n* Flag expressions with multiple explicit resource allocations (problem: how many direct resource allocations can we recognize?)\n\n### <a name=\"rr-ap\"></a>R.14: Avoid `[]` parameters, prefer `span`\n\n##### Reason\n\nAn array decays to a pointer, thereby losing its size, opening the opportunity for range errors.\nUse `span` to preserve size information.\n\n##### Example\n\n    void f(int[]);          // not recommended\n\n    void f(int*);           // not recommended for multiple objects\n                            // (a pointer should point to a single object, do not subscript)\n\n    void f(gsl::span<int>); // good, recommended\n\n##### Enforcement\n\nFlag `[]` parameters. Use `span` instead.\n\n### <a name=\"rr-pair\"></a>R.15: Always overload matched allocation/deallocation pairs\n\n##### Reason\n\nOtherwise you get mismatched operations and chaos.\n\n##### Example\n\n    class X {\n        // ...\n        void* operator new(size_t s);\n        void operator delete(void*);\n        // ...\n    };\n\n##### Note\n\nIf you want memory that cannot be deallocated, `=delete` the deallocation operation.\nDon't leave it undeclared.\n\n##### Enforcement\n\nFlag incomplete pairs.\n\n## <a name=\"ss-smart\"></a>R.smart: Smart pointers\n\n### <a name=\"rr-owner\"></a>R.20: Use `unique_ptr` or `shared_ptr` to represent ownership\n\n##### Reason\n\nThey can prevent resource leaks.\n\n##### Example\n\nConsider:\n\n    void f()\n    {\n        X* p1 { new X };              // bad, p1 will leak\n        auto p2 = make_unique<X>();   // good, unique ownership\n        auto p3 = make_shared<X>();   // good, shared ownership\n    }\n\nThis will leak the object used to initialize `p1` (only).\n\n##### Enforcement\n\n* (Simple) Warn if the return value of `new` is assigned to a raw pointer.\n* (Simple) Warn if the result of a function returning a raw owning pointer is assigned to a raw pointer.\n\n### <a name=\"rr-unique\"></a>R.21: Prefer `unique_ptr` over `shared_ptr` unless you need to share ownership\n\n##### Reason\n\nA `unique_ptr` is conceptually simpler and more predictable (you know when destruction happens) and faster (you don't implicitly maintain a use count).\n\n##### Example, bad\n\nThis needlessly adds and maintains a reference count.\n\n    void f()\n    {\n        shared_ptr<Base> base = make_shared<Derived>();\n        // use base locally, without copying it -- refcount never exceeds 1\n    } // destroy base\n\n##### Example\n\nThis is more efficient:\n\n    void f()\n    {\n        unique_ptr<Base> base = make_unique<Derived>();\n        // use base locally\n    } // destroy base\n\n##### Enforcement\n\n(Simple) Warn if a function uses a `Shared_pointer` with an object allocated within the function, but never returns the `Shared_pointer` or passes it to a function requiring a `Shared_pointer`. Suggest using `unique_ptr` instead.\n\n### <a name=\"rr-make_shared\"></a>R.22: Use `make_shared()` to make `shared_ptr`s\n\n##### Reason\n\n`make_shared` gives a more concise statement of the construction.\nIt also gives an opportunity to eliminate a separate allocation for the reference counts, by placing the `shared_ptr`'s use counts next to its object.\nIt also ensures exception safety in complex expressions (in pre-C++17 code).\n\n##### Example\n\nConsider:\n\n    shared_ptr<X> p1 { new X{2} }; // bad\n    auto p = make_shared<X>(2);    // good\n\nThe `make_shared()` version mentions `X` only once, so it is usually shorter (as well as faster) than the version with the explicit `new`.\n\n##### Enforcement\n\n(Simple) Warn if a `shared_ptr` is constructed from the result of `new` rather than `make_shared`.\n\n### <a name=\"rr-make_unique\"></a>R.23: Use `make_unique()` to make `unique_ptr`s\n\n##### Reason\n\n`make_unique` gives a more concise statement of the construction.\nIt also ensures exception safety in complex expressions (in pre-C++17 code).\n\n##### Example\n\n    unique_ptr<Foo> p {new Foo{7}};    // OK: but repetitive\n\n    auto q = make_unique<Foo>(7);      // Better: no repetition of Foo\n\n##### Enforcement\n\n(Simple) Warn if a `unique_ptr` is constructed from the result of `new` rather than `make_unique`.\n\n### <a name=\"rr-weak_ptr\"></a>R.24: Use `std::weak_ptr` to break cycles of `shared_ptr`s\n\n##### Reason\n\n `shared_ptr`s rely on use counting and the use count for a cyclic structure never goes to zero, so we need a mechanism to\nbe able to destroy a cyclic structure.\n\n##### Example\n\n    #include <memory>\n\n    class bar;\n\n    class foo {\n    public:\n      explicit foo(const std::shared_ptr<bar>& forward_reference)\n        : forward_reference_(forward_reference)\n      { }\n    private:\n      std::shared_ptr<bar> forward_reference_;\n    };\n\n    class bar {\n    public:\n      explicit bar(const std::weak_ptr<foo>& back_reference)\n        : back_reference_(back_reference)\n      { }\n      void do_something()\n      {\n        if (auto shared_back_reference = back_reference_.lock()) {\n          // Use *shared_back_reference\n        }\n      }\n    private:\n      std::weak_ptr<foo> back_reference_;\n    };\n\n##### Note\n\n ??? (HS: A lot of people say \"to break cycles\", while I think \"temporary shared ownership\" is more to the point.)\n???(BS: breaking cycles is what you must do; temporarily sharing ownership is how you do it.\nYou could \"temporarily share ownership\" simply by using another `shared_ptr`.)\n\n##### Enforcement\n\n??? probably impossible. If we could statically detect cycles, we wouldn't need `weak_ptr`\n\n### <a name=\"rr-smartptrparam\"></a>R.30: Take smart pointers as parameters only to explicitly express lifetime semantics\n\nSee [F.7](#rf-smart).\n\n### <a name=\"rr-smart\"></a>R.31: If you have non-`std` smart pointers, follow the basic pattern from `std`\n\n##### Reason\n\nThe rules in the following section also work for other kinds of third-party and custom smart pointers and are very useful for diagnosing common smart pointer errors that cause performance and correctness problems.\nYou want the rules to work on all the smart pointers you use.\n\nAny type (including primary template or specialization) that overloads unary `*` and `->` is considered a smart pointer:\n\n* If it is copyable, it is recognized as a reference-counted `shared_ptr`.\n* If it is not copyable, it is recognized as a unique `unique_ptr`.\n\n##### Example, bad\n\n    // use Boost's intrusive_ptr\n    #include <boost/intrusive_ptr.hpp>\n    void f(boost::intrusive_ptr<widget> p)  // error under rule 'sharedptrparam'\n    {\n        p->foo();\n    }\n\n    // use Microsoft's CComPtr\n    #include <atlbase.h>\n    void f(CComPtr<widget> p)               // error under rule 'sharedptrparam'\n    {\n        p->foo();\n    }\n\nBoth cases are an error under the [`sharedptrparam` guideline](#rr-smartptrparam):\n`p` is a `Shared_pointer`, but nothing about its sharedness is used here and passing it by value is a silent pessimization;\nthese functions should accept a smart pointer only if they need to participate in the widget's lifetime management. Otherwise they should accept a `widget*`, if it can be `nullptr`. Otherwise, and ideally, the function should accept a `widget&`.\nThese smart pointers match the `Shared_pointer` concept, so these guideline enforcement rules work on them out of the box and expose this common pessimization.\n\n### <a name=\"rr-uniqueptrparam\"></a>R.32: Take a `unique_ptr<widget>` parameter to express that a function assumes ownership of a `widget`\n\n##### Reason\n\nUsing `unique_ptr` in this way both documents and enforces the function call's ownership transfer.\n\n##### Example\n\n    void sink(unique_ptr<widget>); // takes ownership of the widget\n\n    void uses(widget*);            // just uses the widget\n\n##### Enforcement\n\n* (Simple) Warn if a function takes a `Unique_pointer<T>` parameter by lvalue reference and does not either assign to it or call `reset()` on it on at least one code path. Suggest taking a `T*` or `T&` instead.\n\n### <a name=\"rr-reseat\"></a>R.33: Take a `unique_ptr<widget>&` parameter to express that a function reseats the `widget`\n\n##### Reason\n\nUsing `unique_ptr` in this way both documents and enforces the function call's reseating semantics.\n\n##### Note\n\n\"reseat\" means \"making a pointer or a smart pointer refer to a different object.\"\n\n##### Example\n\n    void reseat(unique_ptr<widget>&); // \"will\" or \"might\" reseat pointer\n\n##### Enforcement\n\n* (Simple) Warn if a function takes a `Unique_pointer<T>` parameter by lvalue reference and does not either assign to it or call `reset()` on it on at least one code path. Suggest taking a `T*` or `T&` instead.\n\n### <a name=\"rr-sharedptrparam-owner\"></a>R.34: Take a `shared_ptr<widget>` parameter to express shared ownership\n\n##### Reason\n\nThis makes the function's ownership sharing explicit.\n\n##### Example, good\n\n    class WidgetUser\n    {\n    public:\n        // WidgetUser will share ownership of the widget\n        explicit WidgetUser(std::shared_ptr<widget> w) noexcept:\n            m_widget{std::move(w)} {}\n        // ...\n    private:\n        std::shared_ptr<widget> m_widget;\n    };\n\n##### Enforcement\n\n* (Simple) Warn if a function takes a `Shared_pointer<T>` parameter by lvalue reference and does not either assign to it or call `reset()` on it on at least one code path. Suggest taking a `T*` or `T&` instead.\n* (Simple) ((Foundation)) Warn if a function takes a `Shared_pointer<T>` by value or by reference to `const` and does not copy or move it to another `Shared_pointer` on at least one code path. Suggest taking a `T*` or `T&` instead.\n* (Simple) ((Foundation)) Warn if a function takes a `Shared_pointer<T>` by rvalue reference. Suggesting taking it by value instead.\n\n### <a name=\"rr-sharedptrparam\"></a>R.35: Take a `shared_ptr<widget>&` parameter to express that a function might reseat the shared pointer\n\n##### Reason\n\nThis makes the function's reseating explicit.\n\n##### Note\n\n\"reseat\" means \"making a reference or a smart pointer refer to a different object.\"\n\n##### Example, good\n\n    void ChangeWidget(std::shared_ptr<widget>& w)\n    {\n        // This will change the callers widget\n        w = std::make_shared<widget>(widget{});\n    }\n\n##### Enforcement\n\n* (Simple) Warn if a function takes a `Shared_pointer<T>` parameter by lvalue reference and does not either assign to it or call `reset()` on it on at least one code path. Suggest taking a `T*` or `T&` instead.\n* (Simple) ((Foundation)) Warn if a function takes a `Shared_pointer<T>` by value or by reference to `const` and does not copy or move it to another `Shared_pointer` on at least one code path. Suggest taking a `T*` or `T&` instead.\n* (Simple) ((Foundation)) Warn if a function takes a `Shared_pointer<T>` by rvalue reference. Suggesting taking it by value instead.\n\n### <a name=\"rr-sharedptrparam-const\"></a>R.36: Take a `const shared_ptr<widget>&` parameter to express that it might retain a reference count to the object ???\n\n##### Reason\n\nThis makes the function's ??? explicit.\n\n##### Example, good\n\n    void share(shared_ptr<widget>);            // share -- \"will\" retain refcount\n\n    void reseat(shared_ptr<widget>&);          // \"might\" reseat ptr\n\n    void may_share(const shared_ptr<widget>&); // \"might\" retain refcount\n\n##### Enforcement\n\n* (Simple) Warn if a function takes a `Shared_pointer<T>` parameter by lvalue reference and does not either assign to it or call `reset()` on it on at least one code path. Suggest taking a `T*` or `T&` instead.\n* (Simple) ((Foundation)) Warn if a function takes a `Shared_pointer<T>` by value or by reference to `const` and does not copy or move it to another `Shared_pointer` on at least one code path. Suggest taking a `T*` or `T&` instead.\n* (Simple) ((Foundation)) Warn if a function takes a `Shared_pointer<T>` by rvalue reference. Suggesting taking it by value instead.\n\n### <a name=\"rr-smartptrget\"></a>R.37: Do not pass a pointer or reference obtained from an aliased smart pointer\n\n##### Reason\n\nViolating this rule is the number one cause of losing reference counts and finding yourself with a dangling pointer.\nFunctions should prefer to pass raw pointers and references down call chains.\nAt the top of the call tree where you obtain the raw pointer or reference from a smart pointer that keeps the object alive.\nYou need to be sure that the smart pointer cannot inadvertently be reset or reassigned from within the call tree below.\n\n##### Note\n\nTo do this, sometimes you need to take a local copy of a smart pointer, which firmly keeps the object alive for the duration of the function and the call tree.\n\n##### Example\n\nConsider this code:\n\n    // global (static or heap), or aliased local ...\n    shared_ptr<widget> g_p = ...;\n\n    void f(widget& w)\n    {\n        g();\n        use(w);  // A\n    }\n\n    void g()\n    {\n        g_p = ...; // oops, if this was the last shared_ptr to that widget, destroys the widget\n    }\n\nThe following should not pass code review:\n\n    void my_code()\n    {\n        // BAD: passing pointer or reference obtained from a non-local smart pointer\n        //      that could be inadvertently reset somewhere inside f or its callees\n        f(*g_p);\n\n        // BAD: same reason, just passing it as a \"this\" pointer\n        g_p->func();\n    }\n\nThe fix is simple -- take a local copy of the pointer to \"keep a ref count\" for your call tree:\n\n    void my_code()\n    {\n        // cheap: 1 increment covers this entire function and all the call trees below us\n        auto pin = g_p;\n\n        // GOOD: passing pointer or reference obtained from a local unaliased smart pointer\n        f(*pin);\n\n        // GOOD: same reason\n        pin->func();\n    }\n\n##### Enforcement\n\n* (Simple) Warn if a pointer or reference obtained from a smart pointer variable (`Unique_pointer` or `Shared_pointer`) that is non-local, or that is local but potentially aliased, is used in a function call. If the smart pointer is a `Shared_pointer` then suggest taking a local copy of the smart pointer and obtain a pointer or reference from that instead.\n\n# <a name=\"s-expr\"></a>ES: Expressions and statements\n\nExpressions and statements are the lowest and most direct way of expressing actions and computation. Declarations in local scopes are statements.\n\nFor naming, commenting, and indentation rules, see [NL: Naming and layout](#s-naming).\n\nGeneral rules:\n\n* [ES.1: Prefer the standard library to other libraries and to \"handcrafted code\"](#res-lib)\n* [ES.2: Prefer suitable abstractions to direct use of language features](#res-abstr)\n* [ES.3: Don't repeat yourself, avoid redundant code](#res-dry)\n\nDeclaration rules:\n\n* [ES.5: Keep scopes small](#res-scope)\n* [ES.6: Declare names in for-statement initializers and conditions to limit scope](#res-cond)\n* [ES.7: Keep common and local names short, and keep uncommon and non-local names longer](#res-name-length)\n* [ES.8: Avoid similar-looking names](#res-name-similar)\n* [ES.9: Avoid `ALL_CAPS` names](#res-not-caps)\n* [ES.10: Declare one name (only) per declaration](#res-name-one)\n* [ES.11: Use `auto` to avoid redundant repetition of type names](#res-auto)\n* [ES.12: Do not reuse names in nested scopes](#res-reuse)\n* [ES.20: Always initialize an object](#res-always)\n* [ES.21: Don't introduce a variable (or constant) before you need to use it](#res-introduce)\n* [ES.22: Don't declare a variable until you have a value to initialize it with](#res-init)\n* [ES.23: Prefer the `{}`-initializer syntax](#res-list)\n* [ES.24: Use a `unique_ptr<T>` to hold pointers](#res-unique)\n* [ES.25: Declare an object `const` or `constexpr` unless you want to modify its value later on](#res-const)\n* [ES.26: Don't use a variable for two unrelated purposes](#res-recycle)\n* [ES.27: Use `std::array` or `stack_array` for arrays on the stack](#res-stack)\n* [ES.28: Use lambdas for complex initialization, especially of `const` variables](#res-lambda-init)\n* [ES.30: Don't use macros for program text manipulation](#res-macros)\n* [ES.31: Don't use macros for constants or \"functions\"](#res-macros2)\n* [ES.32: Use `ALL_CAPS` for all macro names](#res-all_caps)\n* [ES.33: If you must use macros, give them unique names](#res-macros3)\n* [ES.34: Don't define a (C-style) variadic function](#res-ellipses)\n\nExpression rules:\n\n* [ES.40: Avoid complicated expressions](#res-complicated)\n* [ES.41: If in doubt about operator precedence, parenthesize](#res-parens)\n* [ES.42: Keep use of pointers simple and straightforward](#res-ptr)\n* [ES.43: Avoid expressions with undefined order of evaluation](#res-order)\n* [ES.44: Don't depend on order of evaluation of function arguments](#res-order-fct)\n* [ES.45: Avoid \"magic constants\"; use symbolic constants](#res-magic)\n* [ES.46: Avoid narrowing conversions](#res-narrowing)\n* [ES.47: Use `nullptr` rather than `0` or `NULL`](#res-nullptr)\n* [ES.48: Avoid casts](#res-casts)\n* [ES.49: If you must use a cast, use a named cast](#res-casts-named)\n* [ES.50: Don't cast away `const`](#res-casts-const)\n* [ES.55: Avoid the need for range checking](#res-range-checking)\n* [ES.56: Write `std::move()` only when you need to explicitly move an object to another scope](#res-move)\n* [ES.60: Avoid `new` and `delete` outside resource management functions](#res-new)\n* [ES.61: Delete arrays using `delete[]` and non-arrays using `delete`](#res-del)\n* [ES.62: Don't compare pointers into different arrays](#res-arr2)\n* [ES.63: Don't slice](#res-slice)\n* [ES.64: Use the `T{e}`notation for construction](#res-construct)\n* [ES.65: Don't dereference an invalid pointer](#res-deref)\n\nStatement rules:\n\n* [ES.70: Prefer a `switch`-statement to an `if`-statement when there is a choice](#res-switch-if)\n* [ES.71: Prefer a range-`for`-statement to a `for`-statement when there is a choice](#res-for-range)\n* [ES.72: Prefer a `for`-statement to a `while`-statement when there is an obvious loop variable](#res-for-while)\n* [ES.73: Prefer a `while`-statement to a `for`-statement when there is no obvious loop variable](#res-while-for)\n* [ES.74: Prefer to declare a loop variable in the initializer part of a `for`-statement](#res-for-init)\n* [ES.75: Avoid `do`-statements](#res-do)\n* [ES.76: Avoid `goto`](#res-goto)\n* [ES.77: Minimize the use of `break` and `continue` in loops](#res-continue)\n* [ES.78: Don't rely on implicit fallthrough in `switch` statements](#res-break)\n* [ES.79: Use `default` to handle common cases (only)](#res-default)\n* [ES.84: Don't try to declare a local variable with no name](#res-noname)\n* [ES.85: Make empty statements visible](#res-empty)\n* [ES.86: Avoid modifying loop control variables inside the body of raw for-loops](#res-loop-counter)\n* [ES.87: Don't add redundant `==` or `!=` to conditions](#res-if)\n\nArithmetic rules:\n\n* [ES.100: Don't mix signed and unsigned arithmetic](#res-mix)\n* [ES.101: Use unsigned types for bit manipulation](#res-unsigned)\n* [ES.102: Use signed types for arithmetic](#res-signed)\n* [ES.103: Don't overflow](#res-overflow)\n* [ES.104: Don't underflow](#res-underflow)\n* [ES.105: Don't divide by integer zero](#res-zero)\n* [ES.106: Don't try to avoid negative values by using `unsigned`](#res-nonnegative)\n* [ES.107: Don't use `unsigned` for subscripts, prefer `gsl::index`](#res-subscripts)\n\n### <a name=\"res-lib\"></a>ES.1: Prefer the standard library to other libraries and to \"handcrafted code\"\n\n##### Reason\n\nCode using a library can be much easier to write than code working directly with language features, much shorter, tend to be of a higher level of abstraction, and the library code is presumably already tested.\nThe ISO C++ Standard Library is among the most widely known and best tested libraries.\nIt is available as part of all C++ implementations.\n\n##### Example\n\n    auto sum = accumulate(begin(a), end(a), 0.0);   // good\n\na range version of `accumulate` would be even better:\n\n    auto sum = accumulate(v, 0.0); // better\n\nbut don't hand-code a well-known algorithm:\n\n    int max = v.size();   // bad: verbose, purpose unstated\n    double sum = 0.0;\n    for (int i = 0; i < max; ++i)\n        sum = sum + v[i];\n\n##### Exception\n\nLarge parts of the standard library rely on dynamic allocation (free store). These parts, notably the containers but not the algorithms, are unsuitable for some hard-real-time and embedded applications. In such cases, consider providing/using similar facilities, e.g.,  a standard-library-style container implemented using a pool allocator.\n\n##### Enforcement\n\nNot easy. ??? Look for messy loops, nested loops, long functions, absence of function calls, lack of use of built-in types. Cyclomatic complexity?\n\n### <a name=\"res-abstr\"></a>ES.2: Prefer suitable abstractions to direct use of language features\n\n##### Reason\n\nA \"suitable abstraction\" (e.g., library or class) is closer to the application concepts than the bare language, leads to shorter and clearer code, and is likely to be better tested.\n\n##### Example\n\n    vector<string> read1(istream& is)   // good\n    {\n        vector<string> res;\n        for (string s; is >> s;)\n            res.push_back(s);\n        return res;\n    }\n\nThe more traditional and lower-level near-equivalent is longer, messier, harder to get right, and most likely slower:\n\n    char** read2(istream& is, int maxelem, int maxstring, int* nread)   // bad: verbose and incomplete\n    {\n        auto res = new char*[maxelem];\n        int elemcount = 0;\n        while (is && elemcount < maxelem) {\n            auto s = new char[maxstring];\n            is.read(s, maxstring);\n            res[elemcount++] = s;\n        }\n        *nread = elemcount;\n        return res;\n    }\n\nOnce the checking for overflow and error handling has been added that code gets quite messy, and there is the problem remembering to `delete` the returned pointer and the C-style strings that array contains.\n\n##### Enforcement\n\nNot easy. ??? Look for messy loops, nested loops, long functions, absence of function calls, lack of use of built-in types. Cyclomatic complexity?\n\n### <a name=\"res-dry\"></a>ES.3: Don't repeat yourself, avoid redundant code\n\nDuplicated or otherwise redundant code obscures intent, makes it harder to understand the logic, and makes maintenance harder, among other problems. It often arises from cut-and-paste programming.\n\nUse standard algorithms where appropriate, instead of writing some own implementation.\n\n**See also**: [SL.1](#rsl-lib), [ES.11](#res-auto)\n\n##### Example\n\n    void func(bool flag)    // Bad, duplicated code.\n    {\n        if (flag) {\n            x();\n            y();\n        }\n        else {\n            x();\n            z();\n        }\n    }\n\n    void func(bool flag)    // Better, no duplicated code.\n    {\n        x();\n\n        if (flag)\n            y();\n        else\n            z();\n    }\n\n\n##### Enforcement\n\n* Use a static analyzer. It will catch at least some redundant constructs.\n* Code review\n\n## ES.dcl: Declarations\n\nA declaration is a statement. A declaration introduces a name into a scope and might cause the construction of a named object.\n\n### <a name=\"res-scope\"></a>ES.5: Keep scopes small\n\n##### Reason\n\nReadability. Minimize resource retention. Avoid accidental misuse of value.\n\n**Alternative formulation**: Don't declare a name in an unnecessarily large scope.\n\n##### Example\n\n    void use()\n    {\n        int i;    // bad: i is needlessly accessible after loop\n        for (i = 0; i < 20; ++i) { /* ... */ }\n        // no intended use of i here\n        for (int i = 0; i < 20; ++i) { /* ... */ }  // good: i is local to for-loop\n\n        if (auto pc = dynamic_cast<Circle*>(ps)) {  // good: pc is local to if-statement\n            // ... deal with Circle ...\n        }\n        else {\n            // ... handle error ...\n        }\n    }\n\n##### Example, bad\n\n    void use(const string& name)\n    {\n        string fn = name + \".txt\";\n        ifstream is {fn};\n        Record r;\n        is >> r;\n        // ... 200 lines of code without intended use of fn or is ...\n    }\n\nThis function is by most measures too long anyway, but the point is that the resources used by `fn` and the file handle held by `is`\nare retained for much longer than needed and that unanticipated use of `is` and `fn` could happen later in the function.\nIn this case, it might be a good idea to factor out the read:\n\n    Record load_record(const string& name)\n    {\n        string fn = name + \".txt\";\n        ifstream is {fn};\n        Record r;\n        is >> r;\n        return r;\n    }\n\n    void use(const string& name)\n    {\n        Record r = load_record(name);\n        // ... 200 lines of code ...\n    }\n\n##### Enforcement\n\n* Flag loop variable declared outside a loop and not used after the loop\n* Flag when expensive resources, such as file handles and locks are not used for N-lines (for some suitable N)\n\n### <a name=\"res-cond\"></a>ES.6: Declare names in for-statement initializers and conditions to limit scope\n\n##### Reason\n\nReadability.\nLimit the loop variable visibility to the scope of the loop.\nAvoid using the loop variable for other purposes after the loop.\nMinimize resource retention.\n\n##### Example\n\n    void use()\n    {\n        for (string s; cin >> s;)\n            v.push_back(s);\n\n        for (int i = 0; i < 20; ++i) {   // good: i is local to for-loop\n            // ...\n        }\n\n        if (auto pc = dynamic_cast<Circle*>(ps)) {   // good: pc is local to if-statement\n            // ... deal with Circle ...\n        }\n        else {\n            // ... handle error ...\n        }\n    }\n\n##### Example, don't\n\n    int j;                            // BAD: j is visible outside the loop\n    for (j = 0; j < 100; ++j) {\n        // ...\n    }\n    // j is still visible here and isn't needed\n\n**See also**: [Don't use a variable for two unrelated purposes](#res-recycle)\n\n##### Enforcement\n\n* Warn when a variable modified inside the `for`-statement is declared outside the loop and not being used outside the loop.\n* (hard) Flag loop variables declared before the loop and used after the loop for an unrelated purpose.\n\n**Discussion**: Scoping the loop variable to the loop body also helps code optimizers greatly. Recognizing that the induction variable\nis only accessible in the loop body unblocks optimizations such as hoisting, strength reduction, loop-invariant code motion, etc.\n\n##### C++17 and C++20 example\n\nNote: C++17 and C++20 also add `if`, `switch`, and range-`for` initializer statements. These require C++17 and C++20 support.\n\n    map<int, string> mymap;\n\n    if (auto result = mymap.insert(value); result.second) {\n        // insert succeeded, and result is valid for this block\n        use(result.first);  // ok\n        // ...\n    } // result is destroyed here\n\n##### C++17 and C++20 enforcement (if using a C++17 or C++20 compiler)\n\n* Flag selection/loop variables declared before the body and not used after the body\n* (hard) Flag selection/loop variables declared before the body and used after the body for an unrelated purpose.\n\n### <a name=\"res-name-length\"></a>ES.7: Keep common and local names short, and keep uncommon and non-local names longer\n\n##### Reason\n\nReadability. Lowering the chance of clashes between unrelated non-local names.\n\n##### Example\n\nConventional short, local names increase readability:\n\n    template<typename T>    // good\n    void print(ostream& os, const vector<T>& v)\n    {\n        for (gsl::index i = 0; i < v.size(); ++i)\n            os << v[i] << '\\n';\n    }\n\nAn index is conventionally called `i` and there is no hint about the meaning of the vector in this generic function, so `v` is as good a name as any. Compare\n\n    template<typename Element_type>   // bad: verbose, hard to read\n    void print(ostream& target_stream, const vector<Element_type>& current_vector)\n    {\n        for (gsl::index current_element_index = 0;\n             current_element_index < current_vector.size();\n             ++current_element_index\n        )\n        target_stream << current_vector[current_element_index] << '\\n';\n    }\n\nYes, it is a caricature, but we have seen worse.\n\n##### Example\n\nUnconventional and short non-local names obscure code:\n\n    void use1(const string& s)\n    {\n        // ...\n        tt(s);   // bad: what is tt()?\n        // ...\n    }\n\nBetter, give non-local entities readable names:\n\n    void use1(const string& s)\n    {\n        // ...\n        trim_tail(s);   // better\n        // ...\n    }\n\nHere, there is a chance that the reader knows what `trim_tail` means and that the reader can remember it after looking it up.\n\n##### Example, bad\n\nArgument names of large functions are de facto non-local and should be meaningful:\n\n    void complicated_algorithm(vector<Record>& vr, const vector<int>& vi, map<string, int>& out)\n    // read from events in vr (marking used Records) for the indices in\n    // vi placing (name, index) pairs into out\n    {\n        // ... 500 lines of code using vr, vi, and out ...\n    }\n\nWe recommend keeping functions short, but that rule isn't universally adhered to and naming should reflect that.\n\n##### Enforcement\n\nCheck length of local and non-local names. Also take function length into account.\n\n### <a name=\"res-name-similar\"></a>ES.8: Avoid similar-looking names\n\n##### Reason\n\nCode clarity and readability. Too-similar names slow down comprehension and increase the likelihood of error.\n\n##### Example, bad\n\n    if (readable(i1 + l1 + ol + o1 + o0 + ol + o1 + I0 + l0)) surprise();\n\n##### Example, bad\n\nDo not declare a non-type with the same name as a type in the same scope. This removes the need to disambiguate with a keyword such as `struct` or `enum`. It also removes a source of errors, as `struct X` can implicitly declare `X` if lookup fails.\n\n    struct foo { int n; };\n    struct foo foo();       // BAD, foo is a type already in scope\n    struct foo x = foo();   // requires disambiguation\n\n##### Exception\n\nAntique header files might declare non-types and types with the same name in the same scope.\n\n##### Enforcement\n\n* Check names against a list of known confusing letter and digit combinations.\n* Flag a declaration of a variable, function, or enumerator that hides a class or enumeration declared in the same scope.\n\n### <a name=\"res-not-caps\"></a>ES.9: Avoid `ALL_CAPS` names\n\n##### Reason\n\nSuch names are commonly used for macros. Thus, `ALL_CAPS` name are vulnerable to unintended macro substitution.\n\n##### Example\n\n    // somewhere in some header:\n    #define NE !=\n\n    // somewhere else in some other header:\n    enum Coord { N, NE, NW, S, SE, SW, E, W };\n\n    // somewhere third in some poor programmer's .cpp:\n    switch (direction) {\n    case N:\n        // ...\n    case NE:\n        // ...\n    // ...\n    }\n\n##### Note\n\nDo not use `ALL_CAPS` for constants just because constants used to be macros.\n\n##### Enforcement\n\nFlag all uses of ALL CAPS. For older code, accept ALL CAPS for macro names and flag all non-all-CAPS macro names.\n\n### <a name=\"res-name-one\"></a>ES.10: Declare one name (only) per declaration\n\n##### Reason\n\nOne declaration per line increases readability and avoids mistakes related to\nthe C/C++ grammar. It also leaves room for a more descriptive end-of-line\ncomment.\n\n##### Example, bad\n\n    char *p, c, a[7], *pp[7], **aa[10];   // yuck!\n\n##### Exception\n\nA function declaration can contain several function argument declarations.\n\n##### Exception\n\nA structured binding (C++17) is specifically designed to introduce several variables:\n\n    auto [iter, inserted] = m.insert_or_assign(k, val);\n    if (inserted) { /* new entry was inserted */ }\n\n##### Example\n\n    template<class InputIterator, class Predicate>\n    bool any_of(InputIterator first, InputIterator last, Predicate pred);\n\nor better using concepts:\n\n    bool any_of(input_iterator auto first, input_iterator auto last, predicate auto pred);\n\n##### Example\n\n    double scalbn(double x, int n);   // OK: x * pow(FLT_RADIX, n); FLT_RADIX is usually 2\n\nor:\n\n    double scalbn(    // better: x * pow(FLT_RADIX, n); FLT_RADIX is usually 2\n        double x,     // base value\n        int n         // exponent\n    );\n\nor:\n\n    // better: base * pow(FLT_RADIX, exponent); FLT_RADIX is usually 2\n    double scalbn(double base, int exponent);\n\n##### Example\n\n    int a = 10, b = 11, c = 12, d, e = 14, f = 15;\n\nIn a long list of declarators it is easy to overlook an uninitialized variable.\n\n##### Enforcement\n\nFlag variable and constant declarations with multiple declarators (e.g., `int* p, q;`)\n\n### <a name=\"res-auto\"></a>ES.11: Use `auto` to avoid redundant repetition of type names\n\n##### Reason\n\n* Simple repetition is tedious and error-prone.\n* When you use `auto`, the name of the declared entity is in a fixed position in the declaration, increasing readability.\n* In a function template declaration the return type can be a member type.\n\n##### Example\n\nConsider:\n\n    auto p = v.begin();      // vector<DataRecord>::iterator\n    auto z1 = v[3];          // makes copy of DataRecord\n    auto& z2 = v[3];         // avoids copy\n    const auto& z3 = v[3];   // const and avoids copy\n    auto h = t.future();\n    auto q = make_unique<int[]>(s);\n    auto f = [](int x) { return x + 10; };\n\nIn each case, we save writing a longish, hard-to-remember type that the compiler already knows but a programmer could get wrong.\n\n##### Example\n\n    template<class T>\n    auto Container<T>::first() -> Iterator;   // Container<T>::Iterator\n\n##### Exception\n\nAvoid `auto` for initializer lists and in cases where you know exactly which type you want and where an initializer might require conversion.\n\n##### Example\n\n    auto lst = { 1, 2, 3 };   // lst is an initializer list\n    auto x{1};   // x is an int (in C++17; initializer_list in C++11)\n\n##### Note\n\nAs of C++20, we can (and should) use concepts to be more specific about the type we are deducing:\n\n    // ...\n    forward_iterator auto p = algo(x, y, z);\n\n##### Example (C++17)\n\n    std::set<int> values;\n    // ...\n    auto [ position, newly_inserted ] = values.insert(5);   // break out the members of the std::pair\n\n##### Enforcement\n\nFlag redundant repetition of type names in a declaration.\n\n### <a name=\"res-reuse\"></a>ES.12: Do not reuse names in nested scopes\n\n##### Reason\n\nIt is easy to get confused about which variable is used.\nCan cause maintenance problems.\n\n##### Example, bad\n\n    int d = 0;\n    // ...\n    if (cond) {\n        // ...\n        d = 9;\n        // ...\n    }\n    else {\n        // ...\n        int d = 7;\n        // ...\n        d = value_to_be_returned;\n        // ...\n    }\n\n    return d;\n\nIf this is a large `if`-statement, it is easy to overlook that a new `d` has been introduced in the inner scope.\nThis is a known source of bugs.\nSometimes such reuse of a name in an inner scope is called \"shadowing\".\n\n##### Note\n\nShadowing is primarily a problem when functions are too large and too complex.\n\n##### Example\n\nShadowing of function arguments in the outermost block is disallowed by the language:\n\n    void f(int x)\n    {\n        int x = 4;  // error: reuse of function argument name\n\n        if (x) {\n            int x = 7;  // allowed, but bad\n            // ...\n        }\n    }\n\n##### Example, bad\n\nReuse of a member name as a local variable can also be a problem:\n\n    struct S {\n        int m;\n        void f(int x);\n    };\n\n    void S::f(int x)\n    {\n        m = 7;    // assign to member\n        if (x) {\n            int m = 9;\n            // ...\n            m = 99; // assign to local variable\n            // ...\n        }\n    }\n\n##### Exception\n\nWe often reuse function names from a base class in a derived class:\n\n    struct B {\n        void f(int);\n    };\n\n    struct D : B {\n        void f(double);\n        using B::f;\n    };\n\nThis is error-prone.\nFor example, had we forgotten the using declaration, a call `d.f(1)` would not have found the `int` version of `f`.\n\n??? Do we need a specific rule about shadowing/hiding in class hierarchies?\n\n##### Enforcement\n\n* Flag reuse of a name in nested local scopes\n* Flag reuse of a member name as a local variable in a member function\n* Flag reuse of a global name as a local variable or a member name\n* Flag reuse of a base class member name in a derived class (except for function names)\n\n### <a name=\"res-always\"></a>ES.20: Always initialize an object\n\n##### Reason\n\nAvoid used-before-set errors and their associated undefined behavior.\nAvoid problems with comprehension of complex initialization.\nSimplify refactoring.\n\n##### Example\n\n    void use(int arg)\n    {\n        int i;   // bad: uninitialized variable\n        // ...\n        i = 7;   // initialize i\n    }\n\nNo, `i = 7` does not initialize `i`; it assigns to it. Also, `i` can be read in the `...` part. Better:\n\n    void use(int arg)   // OK\n    {\n        int i = 7;   // OK: initialized\n        string s;    // OK: default initialized\n        // ...\n    }\n\n##### Note\n\nThe *always initialize* rule is deliberately stronger than the *an object must be set before used* language rule.\nThe latter, more relaxed rule, catches the technical bugs, but:\n\n* It leads to less readable code\n* It encourages people to declare names in greater than necessary scopes\n* It leads to harder to read code\n* It leads to logic bugs by encouraging complex code\n* It hampers refactoring\n\nThe *always initialize* rule is a style rule aimed to improve maintainability as well as a rule protecting against used-before-set errors.\n\n##### Example\n\nHere is an example that is often considered to demonstrate the need for a more relaxed rule for initialization\n\n    widget i;    // \"widget\" a type that's expensive to initialize, possibly a large trivial type\n    widget j;\n\n    if (cond) {  // bad: i and j are initialized \"late\"\n        i = f1();\n        j = f2();\n    }\n    else {\n        i = f3();\n        j = f4();\n    }\n\nThis cannot trivially be rewritten to initialize `i` and `j` with initializers.\nNote that for types with a default constructor, attempting to postpone initialization simply leads to a default initialization followed by an assignment.\nA popular reason for such examples is \"efficiency\", but a compiler that can detect whether we made a used-before-set error can also eliminate any redundant double initialization.\n\nAssuming that there is a logical connection between `i` and `j`, that connection should probably be expressed in code:\n\n    pair<widget, widget> make_related_widgets(bool x)\n    {\n        return (x) ? {f1(), f2()} : {f3(), f4()};\n    }\n\n    auto [i, j] = make_related_widgets(cond);    // C++17\n\nIf the `make_related_widgets` function is otherwise redundant,\nwe can eliminate it by using a lambda [ES.28](#res-lambda-init):\n\n    auto [i, j] = [x] { return (x) ? pair{f1(), f2()} : pair{f3(), f4()} }();    // C++17\n\nUsing a value representing \"uninitialized\" is a symptom of a problem and not a solution:\n\n    widget i = uninit;  // bad\n    widget j = uninit;\n\n    // ...\n    use(i);         // possibly used before set\n    // ...\n\n    if (cond) {     // bad: i and j are initialized \"late\"\n        i = f1();\n        j = f2();\n    }\n    else {\n        i = f3();\n        j = f4();\n    }\n\nNow the compiler cannot even simply detect a used-before-set. Further, we've introduced complexity in the state space for widget: which operations are valid on an `uninit` widget and which are not?\n\n##### Note\n\nComplex initialization has been popular with clever programmers for decades.\nIt has also been a major source of errors and complexity.\nMany such errors are introduced during maintenance years after the initial implementation.\n\n##### Example\n\nThis rule covers data members.\n\n    class X {\n    public:\n        X(int i, int ci) : m2{i}, cm2{ci} {}\n        // ...\n\n    private:\n        int m1 = 7;\n        int m2;\n        int m3;\n\n        const int cm1 = 7;\n        const int cm2;\n        const int cm3;\n    };\n\nThe compiler will flag the uninitialized `cm3` because it is a `const`, but it will not catch the lack of initialization of `m3`.\nUsually, a rare spurious member initialization is worth the absence of errors from lack of initialization and often an optimizer\ncan eliminate a redundant initialization (e.g., an initialization that occurs immediately before an assignment).\n\n##### Exception\n\nIf you are declaring an object that is just about to be initialized from input, initializing it would cause a double initialization.\nHowever, beware that this might leave uninitialized data beyond the input -- and that has been a fertile source of errors and security breaches:\n\n    constexpr int max = 8 * 1024;\n    int buf[max];         // OK, but suspicious: uninitialized\n    f.read(buf, max);\n\nThe cost of initializing that array could be significant in some situations.\nHowever, such examples do tend to leave uninitialized variables accessible, so they should be treated with suspicion.\n\n    constexpr int max = 8 * 1024;\n    int buf[max] = {};   // zero all elements; better in some situations\n    f.read(buf, max);\n\nBecause of the restrictive initialization rules for arrays and `std::array`, they offer the most compelling examples of the need for this exception.\n\nWhen feasible use a library function that is known not to overflow. For example:\n\n    string s;   // s is default initialized to \"\"\n    cin >> s;   // s expands to hold the string\n\nDon't consider simple variables that are targets for input operations exceptions to this rule:\n\n    int i;   // bad\n    // ...\n    cin >> i;\n\nIn the not uncommon case where the input target and the input operation get separated (as they should not) the possibility of used-before-set opens up.\n\n    int i2 = 0;   // better, assuming that zero is an acceptable value for i2\n    // ...\n    cin >> i2;\n\nA good optimizer should know about input operations and eliminate the redundant operation.\n\n\n##### Note\n\nSometimes, a lambda can be used as an initializer to avoid an uninitialized variable:\n\n    error_code ec;\n    Value v = [&] {\n        auto p = get_value();   // get_value() returns a pair<error_code, Value>\n        ec = p.first;\n        return p.second;\n    }();\n\nor maybe:\n\n    Value v = [] {\n        auto p = get_value();   // get_value() returns a pair<error_code, Value>\n        if (p.first) throw Bad_value{p.first};\n        return p.second;\n    }();\n\n**See also**: [ES.28](#res-lambda-init)\n\n##### Enforcement\n\n* Flag every uninitialized variable.\n  Don't flag variables of user-defined types with default constructors.\n* Check that an uninitialized buffer is written into *immediately* after declaration.\n  Passing an uninitialized variable as a reference to non-`const` argument can be assumed to be a write into the variable.\n\n### <a name=\"res-introduce\"></a>ES.21: Don't introduce a variable (or constant) before you need to use it\n\n##### Reason\n\nReadability. To limit the scope in which the variable can be used.\n\n##### Example\n\n    int x = 7;\n    // ... no use of x here ...\n    ++x;\n\n##### Enforcement\n\nFlag declarations that are distant from their first use.\n\n### <a name=\"res-init\"></a>ES.22: Don't declare a variable until you have a value to initialize it with\n\n##### Reason\n\nReadability. Limit the scope in which a variable can be used. Don't risk used-before-set. Initialization is often more efficient than assignment.\n\n##### Example, bad\n\n    string s;\n    // ... no use of s here ...\n    s = \"what a waste\";\n\n##### Example, bad\n\n    SomeLargeType var;  // Hard-to-read CaMeLcAsEvArIaBlE\n\n    if (cond)   // some non-trivial condition\n        Set(&var);\n    else if (cond2 || !cond3) {\n        var = Set2(3.14);\n    }\n    else {\n        var = 0;\n        for (auto& e : something)\n            var += e;\n    }\n\n    // use var; that this isn't done too early can be enforced statically with only control flow\n\nThis would be fine if there was a default initialization for `SomeLargeType` that wasn't too expensive.\nOtherwise, a programmer might very well wonder if every possible path through the maze of conditions has been covered.\nIf not, we have a \"use before set\" bug. This is a maintenance trap.\n\nFor initializers of moderate complexity, including for `const` variables, consider using a lambda to express the initializer; see [ES.28](#res-lambda-init).\n\n##### Enforcement\n\n* Flag declarations with default initialization that are assigned to before they are first read.\n* Flag any complicated computation after an uninitialized variable and before its use.\n\n### <a name=\"res-list\"></a>ES.23: Prefer the `{}`-initializer syntax\n\n##### Reason\n\nPrefer `{}`. The rules for `{}` initialization are simpler, more general, less ambiguous, and safer than for other forms of initialization.\n\nUse `=` only when you are sure that there can be no narrowing conversions. For built-in arithmetic types, use `=` only with `auto`.\n\nAvoid `()` initialization, which allows parsing ambiguities.\n\n##### Example\n\n    int x {f(99)};\n    int y = x;\n    vector<int> v = {1, 2, 3, 4, 5, 6};\n\n##### Exception\n\nFor containers, there is a tradition for using `{...}` for a list of elements and `(...)` for sizes:\n\n    vector<int> v1(10);    // vector of 10 elements with the default value 0\n    vector<int> v2{10};    // vector of 1 element with the value 10\n\n    vector<int> v3(1, 2);  // vector of 1 element with the value 2\n    vector<int> v4{1, 2};  // vector of 2 elements with the values 1 and 2\n\n##### Note\n\n`{}`-initializers do not allow narrowing conversions (and that is usually a good thing) and allow explicit constructors (which is fine, we're intentionally initializing a new variable).\n\n##### Example\n\n    int x {7.9};   // error: narrowing\n    int y = 7.9;   // OK: y becomes 7. Hope for a compiler warning\n    int z {gsl::narrow_cast<int>(7.9)};    // OK: you asked for it\n    auto zz = gsl::narrow_cast<int>(7.9);  // OK: you asked for it\n\n##### Note\n\n`{}` initialization can be used for nearly all initialization; other forms of initialization can't:\n\n    auto p = new vector<int> {1, 2, 3, 4, 5};   // initialized vector\n    D::D(int a, int b) :m{a, b} {   // member initializer (e.g., m might be a pair)\n        // ...\n    };\n    X var {};   // initialize var to be empty\n    struct S {\n        int m {7};   // default initializer for a member\n        // ...\n    };\n\nFor that reason, `{}`-initialization is often called \"uniform initialization\"\n(though there unfortunately are a few irregularities left).\n\n##### Note\n\nInitialization of a variable declared using `auto` with a single value, e.g., `{v}`, had surprising results until C++17.\nThe C++17 rules are somewhat less surprising:\n\n    auto x1 {7};        // x1 is an int with the value 7\n    auto x2 = {7};      // x2 is an initializer_list<int> with an element 7\n\n    auto x11 {7, 8};    // error: two initializers\n    auto x22 = {7, 8};  // x22 is an initializer_list<int> with elements 7 and 8\n\nUse `={...}` if you really want an `initializer_list<T>`\n\n    auto fib10 = {1, 1, 2, 3, 5, 8, 13, 21, 34, 55};   // fib10 is a list\n\n##### Note\n\n`={}` gives copy initialization whereas `{}` gives direct initialization.\nLike the distinction between copy-initialization and direct-initialization itself, this can lead to surprises.\n`{}` accepts `explicit` constructors; `={}` does not. For example:\n\n    struct Z { explicit Z() {} };\n\n    Z z1{};     // OK: direct initialization, so we use explicit constructor\n    Z z2 = {};  // error: copy initialization, so we cannot use the explicit constructor\n\nUse plain `{}`-initialization unless you specifically want to disable explicit constructors.\n\n##### Example\n\n    template<typename T>\n    void f()\n    {\n        T x1(1);    // T initialized with 1\n        T x0();     // bad: function declaration (often a mistake)\n\n        T y1 {1};   // T initialized with 1\n        T y0 {};    // default initialized T\n        // ...\n    }\n\n**See also**: [Discussion](#???)\n\n##### Enforcement\n\n* Flag uses of `=` to initialize arithmetic types where narrowing occurs.\n* Flag uses of `()` initialization syntax that are actually declarations. (Many compilers should warn on this already.)\n\n### <a name=\"res-unique\"></a>ES.24: Use a `unique_ptr<T>` to hold pointers\n\n##### Reason\n\nUsing `std::unique_ptr` is the simplest way to avoid leaks. It is reliable, it\nmakes the type system do much of the work to validate ownership safety, it\nincreases readability, and it has zero or near zero run-time cost.\n\n##### Example\n\n    void use(bool leak)\n    {\n        auto p1 = make_unique<int>(7);   // OK\n        int* p2 = new int{7};            // bad: might leak\n        // ... no assignment to p2 ...\n        if (leak) return;\n        // ... no assignment to p2 ...\n        vector<int> v(7);\n        v.at(7) = 0;                    // exception thrown\n        delete p2;                      // too late to prevent leaks\n        // ...\n    }\n\nIf `leak == true` the object pointed to by `p2` is leaked and the object pointed to by `p1` is not.\nThe same is the case when `at()` throws. In both cases, the `delete p2` statement is not reached.\n\n##### Enforcement\n\nLook for raw pointers that are targets of `new`, `malloc()`, or functions that might return such pointers.\n\n### <a name=\"res-const\"></a>ES.25: Declare an object `const` or `constexpr` unless you want to modify its value later on\n\n##### Reason\n\nThat way you can't change the value by mistake. That way might offer the compiler optimization opportunities.\n\n##### Example\n\n    void f(int n)\n    {\n        const int bufmax = 2 * n + 2;  // good: we can't change bufmax by accident\n        int xmax = n;                  // suspicious: is xmax intended to change?\n        // ...\n    }\n\n##### Enforcement\n\nLook to see if a variable is actually mutated, and flag it if\nnot. Unfortunately, it might be impossible to detect when a non-`const` was not\n*intended* to vary (vs when it merely did not vary).\n\n### <a name=\"res-recycle\"></a>ES.26: Don't use a variable for two unrelated purposes\n\n##### Reason\n\nReadability and safety.\n\n##### Example, bad\n\n    void use()\n    {\n        int i;\n        for (i = 0; i < 20; ++i) { /* ... */ }\n        for (i = 0; i < 200; ++i) { /* ... */ } // bad: i recycled\n    }\n\n##### Note\n\nAs an optimization, you might want to reuse a buffer as a scratch pad, but even then prefer to limit the variable's scope as much as possible and be careful not to cause bugs from data left in a recycled buffer as this is a common source of security bugs.\n\n    void write_to_file()\n    {\n        std::string buffer;             // to avoid reallocations on every loop iteration\n        for (auto& o : objects) {\n            // First part of the work.\n            generate_first_string(buffer, o);\n            write_to_file(buffer);\n\n            // Second part of the work.\n            generate_second_string(buffer, o);\n            write_to_file(buffer);\n\n            // etc...\n        }\n    }\n\n##### Enforcement\n\nFlag recycled variables.\n\n### <a name=\"res-stack\"></a>ES.27: Use `std::array` or `stack_array` for arrays on the stack\n\n##### Reason\n\nThey are readable and don't implicitly convert to pointers.\nThey are not confused with non-standard extensions of built-in arrays.\n\n##### Example, bad\n\n    const int n = 7;\n    int m = 9;\n\n    void f()\n    {\n        int a1[n];\n        int a2[m];   // error: not ISO C++\n        // ...\n    }\n\n##### Note\n\nThe definition of `a1` is legal C++ and has always been.\nThere is a lot of such code.\nIt is error-prone, though, especially when the bound is non-local.\nAlso, it is a \"popular\" source of errors (buffer overflow, pointers from array decay, etc.).\nThe definition of `a2` is C but not C++ and is considered a security risk.\n\n##### Example\n\n    const int n = 7;\n    int m = 9;\n\n    void f()\n    {\n        array<int, n> a1;\n        stack_array<int> a2(m);\n        // ...\n    }\n\n##### Enforcement\n\n* Flag arrays with non-constant bounds (C-style VLAs)\n* Flag arrays with non-local constant bounds\n\n### <a name=\"res-lambda-init\"></a>ES.28: Use lambdas for complex initialization, especially of `const` variables\n\n##### Reason\n\nIt nicely encapsulates local initialization, including cleaning up scratch variables needed only for the initialization, without needing to create a needless non-local yet non-reusable function. It also works for variables that should be `const` but only after some initialization work.\n\n##### Example, bad\n\n    widget x;   // should be const, but:\n    for (auto i = 2; i <= N; ++i) {          // this could be some\n        x += some_obj.do_something_with(i);  // arbitrarily long code\n    }                                        // needed to initialize x\n    // from here, x should be const, but we can't say so in code in this style\n\n##### Example, good\n\n    const widget x = [&] {\n        widget val;                                // assume that widget has a default constructor\n        for (auto i = 2; i <= N; ++i) {            // this could be some\n            val += some_obj.do_something_with(i);  // arbitrarily long code\n        }                                          // needed to initialize x\n        return val;\n    }();\n\nIf at all possible, reduce the conditions to a simple set of alternatives (e.g., an `enum`) and don't mix up selection and initialization.\n\n##### Enforcement\n\nHard. At best a heuristic. Look for an uninitialized variable followed by a loop assigning to it.\n\n### <a name=\"res-macros\"></a>ES.30: Don't use macros for program text manipulation\n\n##### Reason\n\nMacros are a major source of bugs.\nMacros don't obey the usual scope and type rules.\nMacros ensure that the human reader sees something different from what the compiler sees.\nMacros complicate tool building.\n\n##### Example, bad\n\n    #define Case break; case   /* BAD */\n\nThis innocuous-looking macro makes a single lower case `c` instead of a `C` into a bad flow-control bug.\n\n##### Note\n\nThis rule does not ban the use of macros for \"configuration control\" use in `#ifdef`s, etc.\n\nIn the future, modules are likely to eliminate the need for macros in configuration control.\n\n##### Note\n\nThis rule is meant to also discourage use of `#` for stringification and `##` for concatenation.\nAs usual for macros, there are uses that are \"mostly harmless\", but even these can create problems for tools,\nsuch as auto completers, static analyzers, and debuggers.\nOften the desire to use fancy macros is a sign of an overly complex design.\nAlso, `#` and `##` encourages the definition and use of macros:\n\n    #define CAT(a, b) a ## b\n    #define STRINGIFY(a) #a\n\n    void f(int x, int y)\n    {\n        string CAT(x, y) = \"asdf\";   // BAD: hard for tools to handle (and ugly)\n        string sx2 = STRINGIFY(x);\n        // ...\n    }\n\nThere are workarounds for low-level string manipulation using macros. For example:\n\n    enum E { a, b };\n\n    template<int x>\n    constexpr const char* stringify()\n    {\n        switch (x) {\n        case a: return \"a\";\n        case b: return \"b\";\n        }\n    }\n\n    void f()\n    {\n        string s1 = stringify<a>();\n        string s2 = stringify<b>();\n        // ...\n    }\n\nThis is not as convenient as a macro to define, but as easy to use, has zero overhead, and is typed and scoped.\n\nIn the future, static reflection is likely to eliminate the last needs for the preprocessor for program text manipulation.\n\n##### Enforcement\n\nScream when you see a macro that isn't just used for source control (e.g., `#ifdef`)\n\n### <a name=\"res-macros2\"></a>ES.31: Don't use macros for constants or \"functions\"\n\n##### Reason\n\nMacros are a major source of bugs.\nMacros don't obey the usual scope and type rules.\nMacros don't obey the usual rules for argument passing.\nMacros ensure that the human reader sees something different from what the compiler sees.\nMacros complicate tool building.\n\n##### Example, bad\n\n    #define PI 3.14\n    #define SQUARE(a, b) (a * b)\n\nEven if we hadn't left a well-known bug in `SQUARE` there are much better behaved alternatives; for example:\n\n    constexpr double pi = 3.14;\n    template<typename T> T square(T a, T b) { return a * b; }\n\n##### Enforcement\n\nScream when you see a macro that isn't just used for source control (e.g., `#ifdef`)\n\n### <a name=\"res-all_caps\"></a>ES.32: Use `ALL_CAPS` for all macro names\n\n##### Reason\n\nConvention. Readability. Distinguishing macros.\n\n##### Example\n\n    #define forever for (;;)   /* very BAD */\n\n    #define FOREVER for (;;)   /* Still evil, but at least visible to humans */\n\n##### Enforcement\n\nScream when you see a lower case macro.\n\n### <a name=\"res-macros3\"></a>ES.33: If you must use macros, give them unique names\n\n##### Reason\n\nMacros do not obey scope rules.\n\n##### Example\n\n    #define MYCHAR        /* BAD, will eventually clash with someone else's MYCHAR*/\n\n    #define ZCORP_CHAR    /* Still evil, but less likely to clash */\n\n##### Note\n\nAvoid macros if you can: [ES.30](#res-macros), [ES.31](#res-macros2), and [ES.32](#res-all_caps).\nHowever, there are billions of lines of code littered with macros and a long tradition for using and overusing macros.\nIf you are forced to use macros, use long names and supposedly unique prefixes (e.g., your organization's name) to lower the likelihood of a clash.\n\n##### Enforcement\n\nWarn against short macro names.\n\n### <a name=\"res-ellipses\"></a> ES.34: Don't define a (C-style) variadic function\n\n##### Reason\n\nNot type safe.\nRequires messy cast-and-macro-laden code to get working right.\n\n##### Example\n\n    #include <cstdarg>\n\n    // \"severity\" followed by a zero-terminated list of char*s; write the C-style strings to cerr\n    void error(int severity ...)\n    {\n        va_list ap;             // a magic type for holding arguments\n        va_start(ap, severity); // arg startup: \"severity\" is the first argument of error()\n\n        for (;;) {\n            // treat the next var as a char*; no checking: a cast in disguise\n            char* p = va_arg(ap, char*);\n            if (!p) break;\n            cerr << p << ' ';\n        }\n\n        va_end(ap);             // arg cleanup (don't forget this)\n\n        cerr << '\\n';\n        if (severity) exit(severity);\n    }\n\n    void use()\n    {\n        error(7, \"this\", \"is\", \"an\", \"error\", nullptr);\n        error(7); // crash\n        error(7, \"this\", \"is\", \"an\", \"error\");  // crash\n        const char* is = \"is\";\n        string an = \"an\";\n        error(7, \"this\", is, an, \"error\"); // crash\n    }\n\n**Alternative**: Overloading. Templates. Variadic templates.\n\n    #include <iostream>\n\n    void error(int severity)\n    {\n        std::cerr << '\\n';\n        std::exit(severity);\n    }\n\n    template<typename T, typename... Ts>\n    constexpr void error(int severity, T head, Ts... tail)\n    {\n        std::cerr << head;\n        error(severity, tail...);\n    }\n\n    void use()\n    {\n        error(7); // No crash!\n        error(5, \"this\", \"is\", \"not\", \"an\", \"error\"); // No crash!\n\n        std::string an = \"an\";\n        error(7, \"this\", \"is\", \"not\", an, \"error\"); // No crash!\n\n        error(5, \"oh\", \"no\", nullptr); // Compile error! No need for nullptr.\n    }\n\n\n##### Note\n\nThis is basically the way `printf` is implemented.\n\n##### Enforcement\n\n* Flag definitions of C-style variadic functions.\n* Flag `#include <cstdarg>` and `#include <stdarg.h>`\n\n\n## ES.expr: Expressions\n\nExpressions manipulate values.\n\n### <a name=\"res-complicated\"></a>ES.40: Avoid complicated expressions\n\n##### Reason\n\nComplicated expressions are error-prone.\n\n##### Example\n\n    // bad: assignment hidden in subexpression\n    while ((c = getc()) != -1)\n\n    // bad: two non-local variables assigned in sub-expressions\n    while ((cin >> c1, cin >> c2), c1 == c2)\n\n    // better, but possibly still too complicated\n    for (char c1, c2; cin >> c1 >> c2 && c1 == c2;)\n\n    // OK: if i and j are not aliased\n    int x = ++i + ++j;\n\n    // OK: if i != j and i != k\n    v[i] = v[j] + v[k];\n\n    // bad: multiple assignments \"hidden\" in subexpressions\n    x = a + (b = f()) + (c = g()) * 7;\n\n    // bad: relies on commonly misunderstood precedence rules\n    x = a & b + c * d && e ^ f == 7;\n\n    // bad: undefined behavior\n    x = x++ + x++ + ++x;\n\nSome of these expressions are unconditionally bad (e.g., they rely on undefined behavior). Others are simply so complicated and/or unusual that even good programmers could misunderstand them or overlook a problem when in a hurry.\n\n##### Note\n\nC++17 tightens up the rules for the order of evaluation\n(left-to-right except right-to-left in assignments, and the order of evaluation of function arguments is unspecified; [see ES.43](#res-order)),\nbut that doesn't change the fact that complicated expressions are potentially confusing.\n\n##### Note\n\nA programmer should know and use the basic rules for expressions.\n\n##### Example\n\n    x = k * y + z;             // OK\n\n    auto t1 = k * y;           // bad: unnecessarily verbose\n    x = t1 + z;\n\n    if (0 <= x && x < max)   // OK\n\n    auto t1 = 0 <= x;        // bad: unnecessarily verbose\n    auto t2 = x < max;\n    if (t1 && t2)            // ...\n\n##### Enforcement\n\nTricky. How complicated must an expression be to be considered complicated? Writing computations as statements with one operation each is also confusing. Things to consider:\n\n* side effects: side effects on multiple non-local variables (for some definition of non-local) can be suspect, especially if the side effects are in separate subexpressions\n* writes to aliased variables\n* more than N operators (and what should N be?)\n* reliance of subtle precedence rules\n* uses undefined behavior (can we catch all undefined behavior?)\n* implementation defined behavior?\n* ???\n\n### <a name=\"res-parens\"></a>ES.41: If in doubt about operator precedence, parenthesize\n\n##### Reason\n\nAvoid errors. Readability. Not everyone has the operator table memorized.\n\n##### Example\n\n    const unsigned int flag = 2;\n    unsigned int a = flag;\n\n    if (a & flag != 0)  // bad: means a&(flag != 0)\n\nNote: We recommend that programmers know their precedence table for the arithmetic operations, the logical operations, but consider mixing bitwise logical operations with other operators in need of parentheses.\n\n    if ((a & flag) != 0)  // OK: works as intended\n\n##### Note\n\nYou should know enough not to need parentheses for:\n\n    if (a < 0 || a <= max) {\n        // ...\n    }\n\n##### Enforcement\n\n* Flag combinations of bitwise-logical operators and other operators.\n* Flag assignment operators not as the leftmost operator.\n* ???\n\n### <a name=\"res-ptr\"></a>ES.42: Keep use of pointers simple and straightforward\n\n##### Reason\n\nComplicated pointer manipulation is a major source of errors.\n\n##### Note\n\nUse `gsl::span` instead.\nPointers should [only refer to single objects](#ri-array).\nPointer arithmetic is fragile and easy to get wrong, the source of many, many bad bugs and security violations.\n`span` is a bounds-checked, safe type for accessing arrays of data.\nAccess into an array with known bounds using a constant as a subscript can be validated by the compiler.\n\n##### Example, bad\n\n    void f(int* p, int count)\n    {\n        if (count < 2) return;\n\n        int* q = p + 1;    // BAD\n\n        ptrdiff_t d;\n        int n;\n        d = (p - &n);      // OK\n        d = (q - p);       // OK\n\n        int n = *p++;      // BAD\n\n        if (count < 6) return;\n\n        p[4] = 1;          // BAD\n\n        p[count - 1] = 2;  // BAD\n\n        use(&p[0], 3);     // BAD\n    }\n\n##### Example, good\n\n    void f(span<int> a) // BETTER: use span in the function declaration\n    {\n        if (a.size() < 2) return;\n\n        int n = a[0];      // OK\n\n        span<int> q = a.subspan(1); // OK\n\n        if (a.size() < 6) return;\n\n        a[4] = 1;          // OK\n\n        a[a.size() - 1] = 2;  // OK\n\n        use(a.data(), 3);  // OK\n    }\n\n##### Note\n\nSubscripting with a variable is difficult for both tools and humans to validate as safe.\n`span` is a run-time bounds-checked, safe type for accessing arrays of data.\n`at()` is another alternative that ensures single accesses are bounds-checked.\nIf iterators are needed to access an array, use the iterators from a `span` constructed over the array.\n\n##### Example, bad\n\n    void f(array<int, 10> a, int pos)\n    {\n        a[pos / 2] = 1; // BAD\n        a[pos - 1] = 2; // BAD\n        a[-1] = 3;    // BAD (but easily caught by tools) -- no replacement, just don't do this\n        a[10] = 4;    // BAD (but easily caught by tools) -- no replacement, just don't do this\n    }\n\n##### Example, good\n\nUse a `span`:\n\n    void f1(span<int, 10> a, int pos) // A1: Change parameter type to use span\n    {\n        a[pos / 2] = 1; // OK\n        a[pos - 1] = 2; // OK\n    }\n\n    void f2(array<int, 10> arr, int pos) // A2: Add local span and use that\n    {\n        span<int> a = {arr.data(), pos};\n        a[pos / 2] = 1; // OK\n        a[pos - 1] = 2; // OK\n    }\n\nUse `at()`:\n\n    void f3(array<int, 10> a, int pos) // ALTERNATIVE B: Use at() for access\n    {\n        at(a, pos / 2) = 1; // OK\n        at(a, pos - 1) = 2; // OK\n    }\n\n##### Example, bad\n\n    void f()\n    {\n        int arr[COUNT];\n        for (int i = 0; i < COUNT; ++i)\n            arr[i] = i; // BAD, cannot use non-constant indexer\n    }\n\n##### Example, good\n\nUse a `span`:\n\n    void f1()\n    {\n        int arr[COUNT];\n        span<int> av = arr;\n        for (int i = 0; i < COUNT; ++i)\n            av[i] = i;\n    }\n\nUse a `span` and range-`for`:\n\n    void f1a()\n    {\n         int arr[COUNT];\n         span<int, COUNT> av = arr;\n         int i = 0;\n         for (auto& e : av)\n             e = i++;\n    }\n\nUse `at()` for access:\n\n    void f2()\n    {\n        int arr[COUNT];\n        for (int i = 0; i < COUNT; ++i)\n            at(arr, i) = i;\n    }\n\nUse a range-`for`:\n\n    void f3()\n    {\n        int arr[COUNT];\n        int i = 0;\n        for (auto& e : arr)\n             e = i++;\n    }\n\n##### Note\n\nTooling can offer rewrites of array accesses that involve dynamic index expressions to use `at()` instead:\n\n    static int a[10];\n\n    void f(int i, int j)\n    {\n        a[i + j] = 12;      // BAD, could be rewritten as ...\n        at(a, i + j) = 12;  // OK -- bounds-checked\n    }\n\n##### Example\n\nTurning an array into a pointer (as the language does essentially always) removes opportunities for checking, so avoid it\n\n    void g(int* p);\n\n    void f()\n    {\n        int a[5];\n        g(a);        // BAD: are we trying to pass an array?\n        g(&a[0]);    // OK: passing one object\n    }\n\nIf you want to pass an array, say so:\n\n    void g(int* p, size_t length);  // old (dangerous) code\n\n    void g1(span<int> av); // BETTER: get g() changed.\n\n    void f2()\n    {\n        int a[5];\n        span<int> av = a;\n\n        g(av.data(), av.size());   // OK, if you have no choice\n        g1(a);                     // OK -- no decay here, instead use implicit span ctor\n    }\n\n##### Enforcement\n\n* Flag any arithmetic operation on an expression of pointer type that results in a value of pointer type.\n* Flag any indexing expression on an expression or variable of array type (either static array or `std::array`) where the indexer is not a compile-time constant expression with a value between `0` and the upper bound of the array.\n* Flag any expression that would rely on implicit conversion of an array type to a pointer type.\n\nThis rule is part of the [bounds-safety profile](#ss-bounds).\n\n\n### <a name=\"res-order\"></a>ES.43: Avoid expressions with undefined order of evaluation\n\n##### Reason\n\nYou have no idea what such code does. Portability.\nEven if it does something sensible for you, it might do something different on another compiler (e.g., the next release of your compiler) or with a different optimizer setting.\n\n##### Note\n\nC++17 tightens up the rules for the order of evaluation:\nleft-to-right except right-to-left in assignments, and the order of evaluation of function arguments is unspecified.\n\nHowever, remember that your code might be compiled with a pre-C++17 compiler (e.g., through cut-and-paste) so don't be too clever.\n\n##### Example\n\n    v[i] = ++i;   //  the result is undefined\n\nA good rule of thumb is that you should not read a value twice in an expression where you write to it.\n\n##### Enforcement\n\nCan be detected by a good analyzer.\n\n### <a name=\"res-order-fct\"></a>ES.44: Don't depend on order of evaluation of function arguments\n\n##### Reason\n\nBecause that order is unspecified.\n\n##### Note\n\nC++17 tightens up the rules for the order of evaluation, but the order of evaluation of function arguments is still unspecified.\n\n##### Example\n\n    int i = 0;\n    f(++i, ++i);\n\nBefore C++17, the behavior is undefined, so the behavior could be anything (e.g., `f(2, 2)`).\nSince C++17, this code does not have undefined behavior, but it is still not specified which argument is evaluated first. The call will be `f(1, 2)` or `f(2, 1)`, but you don't know which.\n\n##### Example\n\nOverloaded operators can lead to order of evaluation problems:\n\n    f1()->m(f2());          // m(f1(), f2())\n    cout << f1() << f2();   // operator<<(operator<<(cout, f1()), f2())\n\nIn C++17, these examples work as expected (left to right) and assignments are evaluated right to left (just as ='s binding is right-to-left)\n\n    f1() = f2();    // undefined behavior in C++14; in C++17, f2() is evaluated before f1()\n\n##### Enforcement\n\nCan be detected by a good analyzer.\n\n### <a name=\"res-magic\"></a>ES.45: Avoid \"magic constants\"; use symbolic constants\n\n##### Reason\n\nUnnamed constants embedded in expressions are easily overlooked and often hard to understand:\n\n##### Example\n\n    for (int m = 1; m <= 12; ++m)   // don't: magic constant 12\n        cout << month[m] << '\\n';\n\nNo, we don't all know that there are 12 months, numbered 1..12, in a year. Better:\n\n    // months are indexed 1..12\n    constexpr int first_month = 1;\n    constexpr int last_month = 12;\n\n    for (int m = first_month; m <= last_month; ++m)   // better\n        cout << month[m] << '\\n';\n\nBetter still, don't expose constants:\n\n    for (auto m : month)\n        cout << m << '\\n';\n\n##### Enforcement\n\nFlag literals in code. Give a pass to `0`, `1`, `nullptr`, `\\n`, `\"\"`, and others on a positive list.\n\n### <a name=\"res-narrowing\"></a>ES.46: Avoid lossy (narrowing, truncating) arithmetic conversions\n\n##### Reason\n\nA narrowing conversion destroys information, often unexpectedly so.\n\n##### Example, bad\n\nA key example is basic narrowing:\n\n    double d = 7.9;\n    int i = d;    // bad: narrowing: i becomes 7\n    i = (int) d;  // bad: we're going to claim this is still not explicit enough\n\n    void f(int x, long y, double d)\n    {\n        char c1 = x;   // bad: narrowing\n        char c2 = y;   // bad: narrowing\n        char c3 = d;   // bad: narrowing\n    }\n\n##### Note\n\nThe guidelines support library offers a `narrow_cast` operation for specifying that narrowing is acceptable and a `narrow` (\"narrow if\") that throws an exception if a narrowing would throw away legal values:\n\n    i = gsl::narrow_cast<int>(d);   // OK (you asked for it): narrowing: i becomes 7\n    i = gsl::narrow<int>(d);        // OK: throws narrowing_error\n\nWe also include lossy arithmetic casts, such as from a negative floating point type to an unsigned integral type:\n\n    double d = -7.9;\n    unsigned u = 0;\n\n    u = d;                               // bad: narrowing\n    u = gsl::narrow_cast<unsigned>(d);   // OK (you asked for it): u becomes 4294967289\n    u = gsl::narrow<unsigned>(d);        // OK: throws narrowing_error\n\n##### Note\n\nThis rule does not apply to [contextual conversions to bool](https://en.cppreference.com/w/cpp/language/implicit_conversion#Contextual_conversions):\n\n    if (ptr) do_something(*ptr);   // OK: ptr is used as a condition\n    bool b = ptr;                  // bad: narrowing\n\n##### Enforcement\n\nA good analyzer can detect all narrowing conversions. However, flagging all narrowing conversions will lead to a lot of false positives. Suggestions:\n\n* Flag all floating-point to integer conversions. (Maybe only `float`->`char` and `double`->`int`. Here be dragons! We need data.)\n* Flag all `long`->`char`. (I suspect `int`->`char` is very common. Here be dragons! We need data.)\n* Consider narrowing conversions for function arguments especially suspect.\n\n### <a name=\"res-nullptr\"></a>ES.47: Use `nullptr` rather than `0` or `NULL`\n\n##### Reason\n\nReadability. Minimize surprises: `nullptr` cannot be confused with an\n`int`. `nullptr` also has a well-specified (very restrictive) type, and thus\nworks in more scenarios where type deduction might do the wrong thing on `NULL`\nor `0`.\n\n##### Example\n\nConsider:\n\n    void f(int);\n    void f(char*);\n    f(0);         // call f(int)\n    f(nullptr);   // call f(char*)\n\n##### Enforcement\n\nFlag uses of `0` and `NULL` for pointers. The transformation might be helped by simple program transformation.\n\n### <a name=\"res-casts\"></a>ES.48: Avoid casts\n\n##### Reason\n\nCasts are a well-known source of errors and make some optimizations unreliable.\n\n##### Example, bad\n\n    double d = 2;\n    auto p = (long*)&d;\n    auto q = (long long*)&d;\n    cout << d << ' ' << *p << ' ' << *q << '\\n';\n\nWhat would you think this fragment prints? The result is at best implementation defined. I got\n\n    2 0 4611686018427387904\n\nAdding\n\n    *q = 666;\n    cout << d << ' ' << *p << ' ' << *q << '\\n';\n\nI got\n\n    3.29048e-321 666 666\n\nSurprised? It is actually undefined behavior, and so could also have crashed the program.\n\n##### Note\n\nProgrammers who write casts typically assume that they know what they are doing,\nor that writing a cast makes the program \"easier to read\".\nIn fact, they often disable the general rules for using values.\nOverload resolution and template instantiation usually pick the right function if there is a right function to pick.\nIf there is not, maybe there ought to be, rather than applying a local fix (cast).\n\n##### Notes\n\nCasts are necessary in a systems programming language.  For example, how else\nwould we get the address of a device register into a pointer?  However, casts\nare seriously overused as well as a major source of errors.\n\nIf you feel the need for a lot of casts, there might be a fundamental design problem.\n\nThe [type profile](#pro-type-reinterpretcast) bans `reinterpret_cast` and C-style casts.\n\nNever cast to `(void)` to ignore a `[[nodiscard]]`return value.\nIf you deliberately want to discard such a result, first think hard about whether that is really a good idea (there is usually a good reason the author of the function or of the return type used `[[nodiscard]]` in the first place).\nIf you still think it's appropriate and your code reviewer agrees, use `std::ignore =` to turn off the warning which is simple, portable, and easy to grep.\n\n##### Alternatives\n\nCasts are widely (mis)used. Modern C++ has rules and constructs that eliminate the need for casts in many contexts, such as\n\n* Use templates\n* Use `std::variant`\n* Rely on the well-defined, safe, implicit conversions between pointer types\n* Use `std::ignore =` to ignore `[[nodiscard]]` values.\n\n##### Enforcement\n\n* Flag all C-style casts, including to `void`.\n* Flag functional style casts using `Type(value)`. Use `Type{value}` instead which is not narrowing. (See [ES.64](#res-construct).)\n* Flag [identity casts](#pro-type-identitycast) between pointer types, where the source and target types are the same (#pro-type-identitycast).\n* Flag an explicit pointer cast that could be [implicit](#pro-type-implicitpointercast).\n\n### <a name=\"res-casts-named\"></a>ES.49: If you must use a cast, use a named cast\n\n##### Reason\n\nReadability. Error avoidance.\nNamed casts are more specific than a C-style or functional cast, allowing the compiler to catch some errors.\n\nThe named casts are:\n\n* `static_cast`\n* `const_cast`\n* `reinterpret_cast`\n* `dynamic_cast`\n* `std::move`         // `move(x)` is an rvalue reference to `x`\n* `std::forward`      // `forward<T>(x)` is an rvalue or an lvalue reference to `x` depending on `T`\n* `gsl::narrow_cast`  // `narrow_cast<T>(x)` is `static_cast<T>(x)`\n* `gsl::narrow`       // `narrow<T>(x)` is `static_cast<T>(x)` if `static_cast<T>(x) == x` or it throws `narrowing_error`\n\n##### Example\n\n    class B { /* ... */ };\n    class D { /* ... */ };\n\n    template<typename D> D* upcast(B* pb)\n    {\n        D* pd0 = pb;                        // error: no implicit conversion from B* to D*\n        D* pd1 = (D*)pb;                    // legal, but what is done?\n        D* pd2 = static_cast<D*>(pb);       // error: D is not derived from B\n        D* pd3 = reinterpret_cast<D*>(pb);  // OK: on your head be it!\n        D* pd4 = dynamic_cast<D*>(pb);      // OK: return nullptr\n        // ...\n    }\n\nThe example was synthesized from real-world bugs where `D` used to be derived from `B`, but someone refactored the hierarchy.\nThe C-style cast is dangerous because it can do any kind of conversion, depriving us of any protection from mistakes (now or in the future).\n\n##### Note\n\nWhen converting between types with no information loss (e.g. from `float` to\n`double` or from `int32` to `int64`), brace initialization might be used instead.\n\n    double d {some_float};\n    int64_t i {some_int32};\n\nThis makes it clear that the type conversion was intended and also prevents\nconversions between types that might result in loss of precision. (It is a\ncompilation error to try to initialize a `float` from a `double` in this fashion,\nfor example.)\n\n##### Note\n\n`reinterpret_cast` can be essential, but the essential uses (e.g., turning a machine address into pointer) are not type safe:\n\n    auto p = reinterpret_cast<Device_register>(0x800);  // inherently dangerous\n\n\n##### Enforcement\n\n* Flag all C-style casts, including to `void`.\n* Flag functional style casts using `Type(value)`. Use `Type{value}` instead which is not narrowing. (See [ES.64](#res-construct).)\n* The [type profile](#pro-type-reinterpretcast) bans `reinterpret_cast`.\n* The [type profile](#pro-type-arithmeticcast) warns when using `static_cast` between arithmetic types.\n\n### <a name=\"res-casts-const\"></a>ES.50: Don't cast away `const`\n\n##### Reason\n\nIt makes a lie out of `const`.\nIf the variable is actually declared `const`, modifying it results in undefined behavior.\n\n##### Example, bad\n\n    void f(const int& x)\n    {\n        const_cast<int&>(x) = 42;   // BAD\n    }\n\n    static int i = 0;\n    static const int j = 0;\n\n    f(i); // silent side effect\n    f(j); // undefined behavior\n\n##### Example\n\nSometimes, you might be tempted to resort to `const_cast` to avoid code duplication, such as when two accessor functions that differ only in `const`-ness have similar implementations. For example:\n\n    class Bar;\n\n    class Foo {\n    public:\n        // BAD, duplicates logic\n        Bar& get_bar()\n        {\n            /* complex logic around getting a non-const reference to my_bar */\n        }\n\n        const Bar& get_bar() const\n        {\n            /* same complex logic around getting a const reference to my_bar */\n        }\n    private:\n        Bar my_bar;\n    };\n\nInstead, prefer to share implementations. Normally, you can just have the non-`const` function call the `const` function. However, when there is complex logic this can lead to the following pattern that still resorts to a `const_cast`:\n\n    class Foo {\n    public:\n        // not great, non-const calls const version but resorts to const_cast\n        Bar& get_bar()\n        {\n            return const_cast<Bar&>(static_cast<const Foo&>(*this).get_bar());\n        }\n        const Bar& get_bar() const\n        {\n            /* the complex logic around getting a const reference to my_bar */\n        }\n    private:\n        Bar my_bar;\n    };\n\nAlthough this pattern is safe when applied correctly, because the caller must have had a non-`const` object to begin with, it's not ideal because the safety is hard to enforce automatically as a checker rule.\n\nInstead, prefer to put the common code in a common helper function -- and make it a template so that it deduces `const`. This doesn't use any `const_cast` at all:\n\n    class Foo {\n    public:                         // good\n              Bar& get_bar()       { return get_bar_impl(*this); }\n        const Bar& get_bar() const { return get_bar_impl(*this); }\n    private:\n        Bar my_bar;\n\n        template<class T>           // good, deduces whether T is const or non-const\n        static auto& get_bar_impl(T& t)\n            { /* the complex logic around getting a possibly-const reference to my_bar */ }\n    };\n\nNote: Don't do large non-dependent work inside a template, which leads to code bloat. For example, a further improvement would be if all or part of `get_bar_impl` can be non-dependent and factored out into a common non-template function, for a potentially big reduction in code size.\n\n##### Exception\n\nYou might need to cast away `const` when calling `const`-incorrect functions.\nPrefer to wrap such functions in inline `const`-correct wrappers to encapsulate the cast in one place.\n\n##### Example\n\nSometimes, \"cast away `const`\" is to allow the updating of some transient information of an otherwise immutable object.\nExamples are caching, memoization, and precomputation.\nSuch examples are often handled as well or better using `mutable` or an indirection than with a `const_cast`.\n\nConsider keeping previously computed results around for a costly operation:\n\n    int compute(int x); // compute a value for x; assume this to be costly\n\n    class Cache {   // some type implementing a cache for an int->int operation\n    public:\n        pair<bool, int> find(int x) const;   // is there a value for x?\n        void set(int x, int v);             // make y the value for x\n        // ...\n    private:\n        // ...\n    };\n\n    class X {\n    public:\n        int get_val(int x)\n        {\n            auto p = cache.find(x);\n            if (p.first) return p.second;\n            int val = compute(x);\n            cache.set(x, val); // insert value for x\n            return val;\n        }\n        // ...\n    private:\n        Cache cache;\n    };\n\nHere, `get_val()` is logically constant, so we would like to make it a `const` member.\nTo do this we still need to mutate `cache`, so people sometimes resort to a `const_cast`:\n\n    class X {   // Suspicious solution based on casting\n    public:\n        int get_val(int x) const\n        {\n            auto p = cache.find(x);\n            if (p.first) return p.second;\n            int val = compute(x);\n            const_cast<Cache&>(cache).set(x, val);   // ugly\n            return val;\n        }\n        // ...\n    private:\n        Cache cache;\n    };\n\nFortunately, there is a better solution:\nState that `cache` is mutable even for a `const` object:\n\n    class X {   // better solution\n    public:\n        int get_val(int x) const\n        {\n            auto p = cache.find(x);\n            if (p.first) return p.second;\n            int val = compute(x);\n            cache.set(x, val);\n            return val;\n        }\n        // ...\n    private:\n        mutable Cache cache;\n    };\n\nAn alternative solution would be to store a pointer to the `cache`:\n\n    class X {   // OK, but slightly messier solution\n    public:\n        int get_val(int x) const\n        {\n            auto p = cache->find(x);\n            if (p.first) return p.second;\n            int val = compute(x);\n            cache->set(x, val);\n            return val;\n        }\n        // ...\n    private:\n        unique_ptr<Cache> cache;\n    };\n\nThat solution is the most flexible, but requires explicit construction and destruction of `*cache`\n(most likely in the constructor and destructor of `X`).\n\nIn any variant, we must guard against data races on the `cache` in multi-threaded code, possibly using a `std::mutex`.\n\n##### Enforcement\n\n* Flag `const_cast`s.\n* This rule is part of the [type-safety profile](#pro-type-constcast) for the related Profile.\n\n### <a name=\"res-range-checking\"></a>ES.55: Avoid the need for range checking\n\n##### Reason\n\nConstructs that cannot overflow do not overflow (and usually run faster):\n\n##### Example\n\n    for (auto& x : v)      // print all elements of v\n        cout << x << '\\n';\n\n    auto p = find(v, x);   // find x in v\n\n##### Enforcement\n\nLook for explicit range checks and heuristically suggest alternatives.\n\n### <a name=\"res-move\"></a>ES.56: Write `std::move()` only when you need to explicitly move an object to another scope\n\n##### Reason\n\nWe move, rather than copy, to avoid duplication and for improved performance.\n\nA move typically leaves behind an empty object ([C.64](#rc-move-semantic)), which can be surprising or even dangerous, so we try to avoid moving from lvalues (they might be accessed later).\n\n##### Notes\n\nMoving is done implicitly when the source is an rvalue (e.g., value in a `return` treatment or a function result), so don't pointlessly complicate code in those cases by writing `move` explicitly. Instead, write short functions that return values, and both the function's return and the caller's accepting of the return will be optimized naturally.\n\nIn general, following the guidelines in this document (including not making variables' scopes needlessly large, writing short functions that return values, returning local variables) help eliminate most need for explicit `std::move`.\n\nExplicit `move` is needed to explicitly move an object to another scope, notably to pass it to a \"sink\" function and in the implementations of the move operations themselves (move constructor, move assignment operator) and swap operations.\n\n##### Example, bad\n\n    void sink(X&& x);   // sink takes ownership of x\n\n    void user()\n    {\n        X x;\n        // error: cannot bind an lvalue to a rvalue reference\n        sink(x);\n        // OK: sink takes the contents of x, x must now be assumed to be empty\n        sink(std::move(x));\n\n        // ...\n\n        // probably a mistake\n        use(x);\n    }\n\nUsually, a `std::move()` is used as an argument to an `&&` parameter.\nAnd after you do that, assume the object has been moved from (see [C.64](#rc-move-semantic)) and don't read its state again until you first set it to a new value.\n\n    void f()\n    {\n        string s1 = \"supercalifragilisticexpialidocious\";\n\n        string s2 = s1;             // ok, takes a copy\n        assert(s1 == \"supercalifragilisticexpialidocious\");  // ok\n\n        // bad, if you want to keep using s1's value\n        string s3 = move(s1);\n\n        // bad, assert will likely fail, s1 likely changed\n        assert(s1 == \"supercalifragilisticexpialidocious\");\n    }\n\n##### Example\n\n    void sink(unique_ptr<widget> p);  // pass ownership of p to sink()\n\n    void f()\n    {\n        auto w = make_unique<widget>();\n        // ...\n        sink(std::move(w));               // ok, give to sink()\n        // ...\n        sink(w);    // Error: unique_ptr is carefully designed so that you cannot copy it\n    }\n\n##### Notes\n\n`std::move()` is a cast to `&&` in disguise; it doesn't itself move anything, but marks a named object as a candidate that can be moved from.\nThe language already knows the common cases where objects can be moved from, especially when returning values from functions, so don't complicate code with redundant `std::move()`s.\n\nNever write `std::move()` just because you've heard \"it's more efficient.\"\nIn general, don't believe claims of \"efficiency\" without data (???).\nIn general, don't complicate your code without reason (??).\nNever write `std::move()` on a const object, it is silently transformed into a copy (see Item 23 in [Meyers15](#Meyers15))\n\n##### Example, bad\n\n    vector<int> make_vector()\n    {\n        vector<int> result;\n        // ... load result with data\n        return std::move(result);       // bad; just write \"return result;\"\n    }\n\nNever write `return move(local_variable);`, because the language already knows the variable is a move candidate.\nWriting `move` in this code won't help, and can actually be detrimental because on some compilers it interferes with RVO (the return value optimization) by creating an additional reference alias to the local variable.\n\n\n##### Example, bad\n\n    vector<int> v = std::move(make_vector());   // bad; the std::move is entirely redundant\n\nNever write `move` on a returned value such as `x = move(f());` where `f` returns by value.\nThe language already knows that a returned value is a temporary object that can be moved from.\n\n##### Example\n\n    void mover(X&& x)\n    {\n        call_something(std::move(x));         // ok\n        call_something(std::forward<X>(x));   // bad, don't std::forward an rvalue reference\n        call_something(x);                    // suspicious, why not std::move?\n    }\n\n    template<class T>\n    void forwarder(T&& t)\n    {\n        call_something(std::move(t));         // bad, don't std::move a forwarding reference\n        call_something(std::forward<T>(t));   // ok\n        call_something(t);                    // suspicious, why not std::forward?\n    }\n\n##### Enforcement\n\n* Flag use of `std::move(x)` where `x` is an rvalue or the language will already treat it as an rvalue, including `return std::move(local_variable);` and `std::move(f())` on a function that returns by value.\n* Flag functions taking an `S&&` parameter if there is no `const S&` overload to take care of lvalues.\n* Flag a `std::move`d argument passed to a parameter, except when the parameter type is an `X&&` rvalue reference or the type is move-only and the parameter is passed by value.\n* Flag when `std::move` is applied to a forwarding reference (`T&&` where `T` is a template parameter type). Use `std::forward` instead.\n* Flag when `std::move` is applied to other than an rvalue reference to non-const. (More general case of the previous rule to cover the non-forwarding cases.)\n* Flag when `std::forward` is applied to an rvalue reference (`X&&` where `X` is a non-template parameter type). Use `std::move` instead.\n* Flag when `std::forward` is applied to other than a forwarding reference. (More general case of the previous rule to cover the non-moving cases.)\n* Flag when an object is potentially moved from and the next operation is a `const` operation; there should first be an intervening non-`const` operation, ideally assignment, to first reset the object's value.\n\n### <a name=\"res-new\"></a>ES.60: Avoid `new` and `delete` outside resource management functions\n\n##### Reason\n\nDirect resource management in application code is error-prone and tedious.\n\n##### Note\n\nThis is also known as the rule of \"No naked `new`!\"\n\n##### Example, bad\n\n    void f(int n)\n    {\n        auto p = new X[n];   // n default constructed Xs\n        // ...\n        delete[] p;\n    }\n\nThere can be code in the `...` part that causes the `delete` never to happen.\n\n**See also**: [R: Resource management](#s-resource)\n\n##### Enforcement\n\nFlag naked `new`s and naked `delete`s.\n\n### <a name=\"res-del\"></a>ES.61: Delete arrays using `delete[]` and non-arrays using `delete`\n\n##### Reason\n\nThat's what the language requires, and mismatches can lead to resource release errors and/or memory corruption.\n\n##### Example, bad\n\n    void f(int n)\n    {\n        auto p = new X[n];   // n default constructed Xs\n        // ...\n        delete p;   // error: just delete the object p, rather than delete the array p[]\n    }\n\n##### Note\n\nThis example not only violates the [no naked `new` rule](#res-new) as in the previous example, it has many more problems.\n\n##### Enforcement\n\n* Flag mismatched `new` and `delete` if they are in the same scope.\n* Flag mismatched `new` and `delete` if they are in a constructor/destructor pair.\n\n### <a name=\"res-arr2\"></a>ES.62: Don't compare pointers into different arrays\n\n##### Reason\n\nThe result of doing so is undefined.\n\n##### Example, bad\n\n    void f()\n    {\n        int a1[7];\n        int a2[9];\n        if (&a1[5] < &a2[7]) {}       // bad: undefined\n        if (0 < &a1[5] - &a2[7]) {}   // bad: undefined\n    }\n\n##### Note\n\nThis example has many more problems.\n\n##### Enforcement\n\n???\n\n### <a name=\"res-slice\"></a>ES.63: Don't slice\n\n##### Reason\n\nSlicing -- that is, copying only part of an object using assignment or initialization -- most often leads to errors because\nthe object was meant to be considered as a whole.\nIn the rare cases where the slicing was deliberate the code can be surprising.\n\n##### Example\n\n    class Shape { /* ... */ };\n    class Circle : public Shape { /* ... */ Point c; int r; };\n\n    Circle c { {0, 0}, 42 };\n    Shape s {c};    // copy construct only the Shape part of Circle\n    s = c;          // or copy assign only the Shape part of Circle\n\n    void assign(const Shape& src, Shape& dest)\n    {\n        dest = src;\n    }\n    Circle c2 { {1, 1}, 43 };\n    assign(c, c2);   // oops, not the whole state is transferred\n    assert(c == c2); // if we supply copying, we should also provide comparison,\n                     // but this will likely return false\n\nThe result will be meaningless because the center and radius will not be copied from `c` into `s`.\nThe first defense against this is to [define the base class `Shape` not to allow this](#rc-copy-virtual).\n\n##### Alternative\n\nIf you mean to slice, define an explicit operation to do so.\nThis saves readers from confusion.\nFor example:\n\n    class Smiley : public Circle {\n        public:\n        Circle copy_circle();\n        // ...\n    };\n\n    Smiley sm { /* ... */ };\n    Circle c1 {sm};  // ideally prevented by the definition of Circle\n    Circle c2 {sm.copy_circle()};\n\n##### Enforcement\n\nWarn against slicing.\n\n### <a name=\"res-construct\"></a>ES.64: Use the `T{e}`notation for construction\n\n##### Reason\n\nThe `T{e}` construction syntax makes it explicit that construction is desired.\nThe `T{e}` construction syntax doesn't allow narrowing.\n`T{e}` is the only safe and general expression for constructing a value of type `T` from an expression `e`.\nThe casts notations `T(e)` and `(T)e` are neither safe nor general.\n\n##### Example\n\nFor built-in types, the construction notation protects against narrowing and reinterpretation\n\n    void use(char ch, int i, double d, char* p, long long lng)\n    {\n        int x1 = int{ch};     // OK, but redundant\n        int x2 = int{d};      // error: double->int narrowing; use a cast if you need to\n        int x3 = int{p};      // error: pointer to->int; use a reinterpret_cast if you really need to\n        int x4 = int{lng};    // error: long long->int narrowing; use a cast if you need to\n\n        int y1 = int(ch);     // OK, but redundant\n        int y2 = int(d);      // bad: double->int narrowing; use a cast if you need to\n        int y3 = int(p);      // bad: pointer to->int; use a reinterpret_cast if you really need to\n        int y4 = int(lng);    // bad: long long->int narrowing; use a cast if you need to\n\n        int z1 = (int)ch;     // OK, but redundant\n        int z2 = (int)d;      // bad: double->int narrowing; use a cast if you need to\n        int z3 = (int)p;      // bad: pointer to->int; use a reinterpret_cast if you really need to\n        int z4 = (int)lng;    // bad: long long->int narrowing; use a cast if you need to\n    }\n\nThe integer to/from pointer conversions are implementation defined when using the `T(e)` or `(T)e` notations, and non-portable\nbetween platforms with different integer and pointer sizes.\n\n##### Note\n\n[Avoid casts](#res-casts) (explicit type conversion) and if you must [prefer named casts](#res-casts-named).\n\n##### Note\n\nWhen unambiguous, the `T` can be left out of `T{e}`.\n\n    complex<double> f(complex<double>);\n\n    auto z = f({2*pi, 1});\n\n##### Note\n\nThe construction notation is the most general [initializer notation](#res-list).\n\n##### Exception\n\n`std::vector` and other containers were defined before we had `{}` as a notation for construction.\nConsider:\n\n    vector<string> vs {10};                           // ten empty strings\n    vector<int> vi1 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};  // ten elements 1..10\n    vector<int> vi2 {10};                             // one element with the value 10\n\nHow do we get a `vector` of 10 default initialized `int`s?\n\n    vector<int> v3(10); // ten elements with value 0\n\nThe use of `()` rather than `{}` for number of elements is conventional (going back to the early 1980s), hard to change, but still\na design error: for a container where the element type can be confused with the number of elements, we have an ambiguity that\nmust be resolved.\nThe conventional resolution is to interpret `{10}` as a list of one element and use `(10)` to distinguish a size.\n\nThis mistake need not be repeated in new code.\nWe can define a type to represent the number of elements:\n\n    struct Count { int n; };\n\n    template<typename T>\n    class Vector {\n    public:\n        Vector(Count n);                     // n default-initialized elements\n        Vector(initializer_list<T> init);    // init.size() elements\n        // ...\n    };\n\n    Vector<int> v1{10};\n    Vector<int> v2{Count{10}};\n    Vector<Count> v3{Count{10}};    // yes, there is still a very minor problem\n\nThe main problem left is to find a suitable name for `Count`.\n\n##### Enforcement\n\nFlag the C-style `(T)e` and functional-style `T(e)` casts.\n\n\n### <a name=\"res-deref\"></a>ES.65: Don't dereference an invalid pointer\n\n##### Reason\n\nDereferencing an invalid pointer, such as `nullptr`, is undefined behavior, typically leading to immediate crashes,\nwrong results, or memory corruption.\n\n##### Note\n\nBy pointer here we mean any indirection to an object, including equivalently an iterator or view.\n\n##### Note\n\nThis rule is an obvious and well-known language rule, but can be hard to follow.\nIt takes good coding style, library support, and static analysis to eliminate violations without major overhead.\nThis is a major part of the discussion of [C++'s model for type- and resource-safety](#Stroustrup15).\n\n**See also**:\n\n* Use [RAII](#rr-raii) to avoid lifetime problems.\n* Use [unique_ptr](#rf-unique_ptr) to avoid lifetime problems.\n* Use [shared_ptr](#rf-shared_ptr) to avoid lifetime problems.\n* Use [references](#rf-ptr-ref) when `nullptr` isn't a possibility.\n* Use [not_null](#rf-nullptr) to catch unexpected `nullptr` early.\n* Use the [bounds profile](#ss-bounds) to avoid range errors.\n\n\n##### Example\n\n    void f()\n    {\n        int x = 0;\n        int* p = &x;\n\n        if (condition()) {\n            int y = 0;\n            p = &y;\n        } // invalidates p\n\n        *p = 42;            // BAD, p might be invalid if the branch was taken\n    }\n\nTo resolve the problem, either extend the lifetime of the object the pointer is intended to refer to, or shorten the lifetime of the pointer (move the dereference to before the pointed-to object's lifetime ends).\n\n    void f1()\n    {\n        int x = 0;\n        int* p = &x;\n\n        int y = 0;\n        if (condition()) {\n            p = &y;\n        }\n\n        *p = 42;            // OK, p points to x or y and both are still in scope\n    }\n\nUnfortunately, most invalid pointer problems are harder to spot and harder to fix.\n\n##### Example\n\n    void f(int* p)\n    {\n        int x = *p; // BAD: how do we know that p is valid?\n    }\n\nThere is a huge amount of such code.\nMost works -- after lots of testing -- but in isolation it is impossible to tell whether `p` could be the `nullptr`.\nConsequently, this is also a major source of errors.\nThere are many approaches to dealing with this potential problem:\n\n    void f1(int* p) // deal with nullptr\n    {\n        if (!p) {\n            // deal with nullptr (allocate, return, throw, make p point to something, whatever)\n        }\n        int x = *p;\n    }\n\nThere are two potential problems with testing for `nullptr`:\n\n* it is not always obvious what to do if we find `nullptr`\n* the test can be redundant and/or relatively expensive\n* it is not obvious if the test is to protect against a violation or part of the required logic.\n\n<!-- comment needed for code block after list -->\n    void f2(int* p) // state that p is not supposed to be nullptr\n    {\n        assert(p);\n        int x = *p;\n    }\n\nThis would carry a cost only when the assertion checking was enabled and would give a compiler/analyzer useful information.\nThis would work even better if/when C++ gets direct support for contracts:\n\n    void f3(int* p) // state that p is not supposed to be nullptr\n        [[expects: p]]\n    {\n        int x = *p;\n    }\n\nAlternatively, we could use `gsl::not_null` to ensure that `p` is not the `nullptr`.\n\n    void f(not_null<int*> p)\n    {\n        int x = *p;\n    }\n\nThese remedies take care of `nullptr` only.\nRemember that there are other ways of getting an invalid pointer.\n\n##### Example\n\n    void f(int* p)  // old code, doesn't use owner\n    {\n        delete p;\n    }\n\n    void g()        // old code: uses naked new\n    {\n        auto q = new int{7};\n        f(q);\n        int x = *q; // BAD: dereferences invalid pointer\n    }\n\n##### Example\n\n    void f()\n    {\n        vector<int> v(10);\n        int* p = &v[5];\n        v.push_back(99); // could reallocate v's elements\n        int x = *p; // BAD: dereferences potentially invalid pointer\n    }\n\n##### Enforcement\n\nThis rule is part of the [lifetime safety profile](#ss-lifetime)\n\n* Flag a dereference of a pointer that points to an object that has gone out of scope\n* Flag a dereference of a pointer that might have been invalidated by assigning a `nullptr`\n* Flag a dereference of a pointer that might have been invalidated by a `delete`\n* Flag a dereference to a pointer to a container element that might have been invalidated by dereference\n\n\n## ES.stmt: Statements\n\nStatements control the flow of control (except for function calls and exception throws, which are expressions).\n\n### <a name=\"res-switch-if\"></a>ES.70: Prefer a `switch`-statement to an `if`-statement when there is a choice\n\n##### Reason\n\n* Readability.\n* Efficiency: A `switch` compares against constants and is usually better optimized than a series of tests in an `if`-`then`-`else` chain.\n* A `switch` enables some heuristic consistency checking. For example, have all values of an `enum` been covered? If not, is there a `default`?\n\n##### Example\n\n    void use(int n)\n    {\n        switch (n) {   // good\n        case 0:\n            // ...\n            break;\n        case 7:\n            // ...\n            break;\n        default:\n            // ...\n            break;\n        }\n    }\n\nrather than:\n\n    void use2(int n)\n    {\n        if (n == 0)   // bad: if-then-else chain comparing against a set of constants\n            // ...\n        else if (n == 7)\n            // ...\n    }\n\n##### Enforcement\n\nFlag `if`-`then`-`else` chains that check against constants (only).\n\n### <a name=\"res-for-range\"></a>ES.71: Prefer a range-`for`-statement to a `for`-statement when there is a choice\n\n##### Reason\n\nReadability. Error prevention. Efficiency.\n\n##### Example\n\n    for (gsl::index i = 0; i < v.size(); ++i)   // bad\n        cout << v[i] << '\\n';\n\n    for (auto p = v.begin(); p != v.end(); ++p)   // bad\n        cout << *p << '\\n';\n\n    for (auto& x : v)    // OK\n        cout << x << '\\n';\n\n    for (gsl::index i = 1; i < v.size(); ++i) // touches two elements: can't be a range-for\n        cout << v[i] + v[i - 1] << '\\n';\n\n    for (gsl::index i = 0; i < v.size(); ++i) // possible side effect: can't be a range-for\n        cout << f(v, &v[i]) << '\\n';\n\n    for (gsl::index i = 0; i < v.size(); ++i) { // body messes with loop variable: can't be a range-for\n        if (i % 2 != 0)\n            cout << v[i] << '\\n'; // output odd elements\n    }\n\nA human or a good static analyzer might determine that there really isn't a side effect on `v` in `f(v, &v[i])` so that the loop can be rewritten.\n\n\"Messing with the loop variable\" in the body of a loop is typically best avoided.\n\n##### Note\n\nDon't use expensive copies of the loop variable of a range-`for` loop:\n\n    for (string s : vs) // ...\n\nThis will copy each element of `vs` into `s`. Better:\n\n    for (string& s : vs) // ...\n\nBetter still, if the loop variable isn't modified or copied:\n\n    for (const string& s : vs) // ...\n\n##### Enforcement\n\nLook at loops, if a traditional loop just looks at each element of a sequence, and there are no side effects on what it does with the elements, rewrite the loop to a ranged-`for` loop.\n\n### <a name=\"res-for-while\"></a>ES.72: Prefer a `for`-statement to a `while`-statement when there is an obvious loop variable\n\n##### Reason\n\nReadability: the complete logic of the loop is visible \"up front\". The scope of the loop variable can be limited.\n\n##### Example\n\n    for (gsl::index i = 0; i < vec.size(); i++) {\n        // do work\n    }\n\n##### Example, bad\n\n    int i = 0;\n    while (i < vec.size()) {\n        // do work\n        i++;\n    }\n\n##### Enforcement\n\n???\n\n### <a name=\"res-while-for\"></a>ES.73: Prefer a `while`-statement to a `for`-statement when there is no obvious loop variable\n\n##### Reason\n\nReadability.\n\n##### Example\n\n    int events = 0;\n    for (; wait_for_event(); ++events) {  // bad, confusing\n        // ...\n    }\n\nThe \"event loop\" is misleading because the `events` counter has nothing to do with the loop condition (`wait_for_event()`).\nBetter\n\n    int events = 0;\n    while (wait_for_event()) {      // better\n        ++events;\n        // ...\n    }\n\n##### Enforcement\n\nFlag actions in `for`-initializers and `for`-increments that do not relate to the `for`-condition.\n\n### <a name=\"res-for-init\"></a>ES.74: Prefer to declare a loop variable in the initializer part of a `for`-statement\n\nSee [ES.6](#res-cond)\n\n### <a name=\"res-do\"></a>ES.75: Avoid `do`-statements\n\n##### Reason\n\nReadability, avoidance of errors.\nThe termination condition is at the end (where it can be overlooked) and the condition is not checked the first time through.\n\n##### Example\n\n    int x;\n    do {\n        cin >> x;\n        // ...\n    } while (x < 0);\n\n##### Note\n\nYes, there are genuine examples where a `do`-statement is a clear statement of a solution, but also many bugs.\n\n##### Enforcement\n\nFlag `do`-statements.\n\n### <a name=\"res-goto\"></a>ES.76: Avoid `goto`\n\n##### Reason\n\nReadability, avoidance of errors. There are better control structures for humans; `goto` is for machine generated code.\n\n##### Exception\n\nBreaking out of a nested loop.\nIn that case, always jump forwards.\n\n    for (int i = 0; i < imax; ++i)\n        for (int j = 0; j < jmax; ++j) {\n            if (a[i][j] > elem_max) goto finished;\n            // ...\n        }\n    finished:\n    // ...\n\n##### Example, bad\n\nThere is a fair amount of use of the C goto-exit idiom:\n\n    void f()\n    {\n        // ...\n            goto exit;\n        // ...\n            goto exit;\n        // ...\n    exit:\n        // ... common cleanup code ...\n    }\n\nThis is an ad-hoc simulation of destructors.\nDeclare your resources with handles with destructors that clean up.\nIf for some reason you cannot handle all cleanup with destructors for the variables used,\nconsider `gsl::finally()` as a cleaner and more reliable alternative to `goto exit`\n\n##### Enforcement\n\n* Flag `goto`. Better still flag all `goto`s that do not jump from a nested loop to the statement immediately after a nest of loops.\n\n### <a name=\"res-continue\"></a>ES.77: Minimize the use of `break` and `continue` in loops\n\n##### Reason\n\n In a non-trivial loop body, it is easy to overlook a `break` or a `continue`.\n\n A `break` in a loop has a dramatically different meaning than a `break` in a `switch`-statement\n (and you can have `switch`-statement in a loop and a loop in a `switch`-case).\n\n##### Example\n\n    switch(x) {\n    case 1 :\n        while (/* some condition */) {\n            // ...\n        break;\n        } // Oops! break switch or break while intended?\n    case 2 :\n        // ...\n        break;\n    }\n\n##### Alternative\n\nOften, a loop that requires a `break` is a good candidate for a function (algorithm), in which case the `break` becomes a `return`.\n\n    //Original code: break inside loop\n    void use1()\n    {\n        std::vector<T> vec = {/* initialized with some values */};\n        T value;\n        for (const T item : vec) {\n            if (/* some condition*/) {\n                value = item;\n                break;\n            }\n        }\n        /* then do something with value */\n    }\n\n    //BETTER: create a function and return inside loop\n    T search(const std::vector<T> &vec)\n    {\n        for (const T &item : vec) {\n            if (/* some condition*/) return item;\n        }\n        return T(); //default value\n    }\n\n    void use2()\n    {\n        std::vector<T> vec = {/* initialized with some values */};\n        T value = search(vec);\n        /* then do something with value */\n    }\n\nOften, a loop that uses `continue` can equivalently and as clearly be expressed by an `if`-statement.\n\n    for (int item : vec) {  // BAD\n        if (item%2 == 0) continue;\n        if (item == 5) continue;\n        if (item > 10) continue;\n        /* do something with item */\n    }\n\n    for (int item : vec) {  // GOOD\n        if (item%2 != 0 && item != 5 && item <= 10) {\n            /* do something with item */\n        }\n    }\n\n##### Note\n\nIf you really need to break out a loop, a `break` is typically better than alternatives such as [modifying the loop variable](#res-loop-counter) or a [`goto`](#res-goto):\n\n\n##### Enforcement\n\n???\n\n### <a name=\"res-break\"></a>ES.78: Don't rely on implicit fallthrough in `switch` statements\n\n##### Reason\n\nAlways end a non-empty `case` with a `break`. Accidentally leaving out a `break` is a fairly common bug.\nA deliberate fallthrough can be a maintenance hazard and should be rare and explicit.\n\n##### Example\n\n    switch (eventType) {\n    case Information:\n        update_status_bar();\n        break;\n    case Warning:\n        write_event_log();\n        // Bad - implicit fallthrough\n    case Error:\n        display_error_window();\n        break;\n    }\n\nMultiple case labels of a single statement is OK:\n\n    switch (x) {\n    case 'a':\n    case 'b':\n    case 'f':\n        do_something(x);\n        break;\n    }\n\nReturn statements in a case label are also OK:\n\n    switch (x) {\n    case 'a':\n        return 1;\n    case 'b':\n        return 2;\n    case 'c':\n        return 3;\n    }\n\n##### Exceptions\n\nIn rare cases if fallthrough is deemed appropriate, be explicit and use the `[[fallthrough]]` annotation:\n\n    switch (eventType) {\n    case Information:\n        update_status_bar();\n        break;\n    case Warning:\n        write_event_log();\n        [[fallthrough]];\n    case Error:\n        display_error_window();\n        break;\n    }\n\n##### Note\n\n##### Enforcement\n\nFlag all implicit fallthroughs from non-empty `case`s.\n\n\n### <a name=\"res-default\"></a>ES.79: Use `default` to handle common cases (only)\n\n##### Reason\n\n Code clarity.\n Improved opportunities for error detection.\n\n##### Example\n\n    enum E { a, b, c, d };\n\n    void f1(E x)\n    {\n        switch (x) {\n        case a:\n            do_something();\n            break;\n        case b:\n            do_something_else();\n            break;\n        default:\n            take_the_default_action();\n            break;\n        }\n    }\n\nHere it is clear that there is a default action and that cases `a` and `b` are special.\n\n##### Example\n\nBut what if there is no default action and you mean to handle only specific cases?\nIn that case, have an empty default or else it is impossible to know if you meant to handle all cases:\n\n    void f2(E x)\n    {\n        switch (x) {\n        case a:\n            do_something();\n            break;\n        case b:\n            do_something_else();\n            break;\n        default:\n            // do nothing for the rest of the cases\n            break;\n        }\n    }\n\nIf you leave out the `default`, a maintainer and/or a compiler might reasonably assume that you intended to handle all cases:\n\n    void f2(E x)\n    {\n        switch (x) {\n        case a:\n            do_something();\n            break;\n        case b:\n        case c:\n            do_something_else();\n            break;\n        }\n    }\n\nDid you forget case `d` or deliberately leave it out?\nForgetting a case typically happens when a case is added to an enumeration and the person doing so fails to add it to every\nswitch over the enumerators.\n\n##### Enforcement\n\nFlag `switch`-statements over an enumeration that don't handle all enumerators and do not have a `default`.\nThis might yield too many false positives in some code bases; if so, flag only `switch`es that handle most but not all cases\n(that was the strategy of the very first C++ compiler).\n\n### <a name=\"res-noname\"></a>ES.84: Don't try to declare a local variable with no name\n\n##### Reason\n\nThere is no such thing.\nWhat looks to a human like a variable without a name is to the compiler a statement consisting of a temporary that immediately goes out of scope.\n\n##### Example, bad\n\n    void f()\n    {\n        lock_guard<mutex>{mx};   // Bad\n        // ...\n    }\n\nThis declares an unnamed `lock_guard` object that immediately goes out of scope at the point of the semicolon.\nThis is not an uncommon mistake.\nIn particular, this particular example can lead to hard-to-find race conditions.\n\n##### Note\n\nUnnamed function arguments are fine.\n\n##### Enforcement\n\nFlag statements that are just a temporary.\n\n### <a name=\"res-empty\"></a>ES.85: Make empty statements visible\n\n##### Reason\n\nReadability.\n\n##### Example\n\n    for (i = 0; i < max; ++i);   // BAD: the empty statement is easily overlooked\n    v[i] = f(v[i]);\n\n    for (auto x : v) {           // better\n        // nothing\n    }\n    v[i] = f(v[i]);\n\n##### Enforcement\n\nFlag empty statements that are not blocks and don't contain comments.\n\n### <a name=\"res-loop-counter\"></a>ES.86: Avoid modifying loop control variables inside the body of raw for-loops\n\n##### Reason\n\nThe loop control up front should enable correct reasoning about what is happening inside the loop. Modifying loop counters in both the iteration-expression and inside the body of the loop is a perennial source of surprises and bugs.\n\n##### Example\n\n    for (int i = 0; i < 10; ++i) {\n        // no updates to i -- ok\n    }\n\n    for (int i = 0; i < 10; ++i) {\n        //\n        if (/* something */) ++i; // BAD\n        //\n    }\n\n    bool skip = false;\n    for (int i = 0; i < 10; ++i) {\n        if (skip) { skip = false; continue; }\n        //\n        if (/* something */) skip = true;  // Better: using two variables for two concepts.\n        //\n    }\n\n##### Enforcement\n\nFlag variables that are potentially updated (have a non-`const` use) in both the loop control iteration-expression and the loop body.\n\n\n### <a name=\"res-if\"></a>ES.87: Don't add redundant `==` or `!=` to conditions\n\n##### Reason\n\nDoing so avoids verbosity and eliminates some opportunities for mistakes.\nHelps make style consistent and conventional.\n\n##### Example\n\nBy definition, a condition in an `if`-statement, `while`-statement, or a `for`-statement selects between `true` and `false`.\nA numeric value is compared to `0` and a pointer value to `nullptr`.\n\n    // These all mean \"if p is not nullptr\"\n    if (p) { ... }            // good\n    if (p != 0) { ... }       // redundant !=0, bad: don't use 0 for pointers\n    if (p != nullptr) { ... } // redundant !=nullptr, not recommended\n\nOften, `if (p)` is read as \"if `p` is valid\" which is a direct expression of the programmers intent,\nwhereas `if (p != nullptr)` would be a long-winded workaround.\n\n##### Example\n\nThis rule is especially useful when a declaration is used as a condition\n\n    if (auto pc = dynamic_cast<Circle*>(ps)) { ... } // execute if ps points to a kind of Circle, good\n\n    if (auto pc = dynamic_cast<Circle*>(ps); pc != nullptr) { ... } // not recommended\n\n##### Example\n\nNote that implicit conversions to bool are applied in conditions.\nFor example:\n\n    for (string s; cin >> s; ) v.push_back(s);\n\nThis invokes `istream`'s `operator bool()`.\n\n##### Note\n\nExplicit comparison of an integer to `0` is in general not redundant.\nThe reason is that (as opposed to pointers and Booleans) an integer often has more than two reasonable values.\nFurthermore `0` (zero) is often used to indicate success.\nConsequently, it is best to be specific about the comparison.\n\n    void f(int i)\n    {\n        if (i)            // suspect\n        // ...\n        if (i == success) // possibly better\n        // ...\n    }\n\nAlways remember that an integer can have more than two values.\n\n##### Example, bad\n\nIt has been noted that\n\n    if(strcmp(p1, p2)) { ... }   // are the two C-style strings equal? (mistake!)\n\nis a common beginners error.\nIf you use C-style strings, you must know the `<cstring>` functions well.\nBeing verbose and writing\n\n    if(strcmp(p1, p2) != 0) { ... }   // are the two C-style strings equal? (mistake!)\n\nwould not in itself save you.\n\n##### Note\n\nThe opposite condition is most easily expressed using a negation:\n\n    // These all mean \"if p is nullptr\"\n    if (!p) { ... }           // good\n    if (p == 0) { ... }       // redundant == 0, bad: don't use 0 for pointers\n    if (p == nullptr) { ... } // redundant == nullptr, not recommended\n\n##### Enforcement\n\nEasy, just check for redundant use of `!=` and `==` in conditions.\n\n\n\n## <a name=\"ss-numbers\"></a>Arithmetic\n\n### <a name=\"res-mix\"></a>ES.100: Don't mix signed and unsigned arithmetic\n\n##### Reason\n\nAvoid wrong results.\n\n##### Example\n\n    int x = -3;\n    unsigned int y = 7;\n\n    cout << x - y << '\\n';  // unsigned result, possibly 4294967286\n    cout << x + y << '\\n';  // unsigned result: 4\n    cout << x * y << '\\n';  // unsigned result, possibly 4294967275\n\nIt is harder to spot the problem in more realistic examples.\n\n##### Note\n\nUnfortunately, C++ uses signed integers for array subscripts and the standard library uses unsigned integers for container subscripts.\nThis precludes consistency. Use `gsl::index` for subscripts; [see ES.107](#res-subscripts).\n\n##### Enforcement\n\n* Compilers already know and sometimes warn.\n* (To avoid noise) Do not flag on a mixed signed/unsigned comparison where one of the arguments is `sizeof` or a call to container `.size()` and the other is `ptrdiff_t`.\n\n\n### <a name=\"res-unsigned\"></a>ES.101: Use unsigned types for bit manipulation\n\n##### Reason\n\nUnsigned types support bit manipulation without surprises from sign bits.\n\n##### Example\n\n    unsigned char x = 0b1010'1010;\n    unsigned char y = ~x;   // y == 0b0101'0101;\n\n##### Note\n\nUnsigned types can also be useful for modular arithmetic.\nHowever, if you want modular arithmetic add\ncomments as necessary noting the reliance on wraparound behavior, as such code\ncan be surprising for many programmers.\n\n##### Enforcement\n\n* Just about impossible in general because of the use of unsigned subscripts in the standard library\n* ???\n\n### <a name=\"res-signed\"></a>ES.102: Use signed types for arithmetic\n\n##### Reason\n\nBecause most arithmetic is assumed to be signed;\n`x - y` yields a negative number when `y > x` except in the rare cases where you really want modular arithmetic.\n\n##### Example\n\nUnsigned arithmetic can yield surprising results if you are not expecting it.\nThis is even more true for mixed signed and unsigned arithmetic.\n\n    template<typename T, typename T2>\n    T subtract(T x, T2 y)\n    {\n        return x - y;\n    }\n\n    void test()\n    {\n        int s = 5;\n        unsigned int us = 5;\n        cout << subtract(s, 7) << '\\n';       // -2\n        cout << subtract(us, 7u) << '\\n';     // 4294967294\n        cout << subtract(s, 7u) << '\\n';      // -2\n        cout << subtract(us, 7) << '\\n';      // 4294967294\n        cout << subtract(s, us + 2) << '\\n';  // -2\n        cout << subtract(us, s + 2) << '\\n';  // 4294967294\n    }\n\nHere we have been very explicit about what's happening,\nbut if you had seen `us - (s + 2)` or `s += 2; ...; us - s`, would you reliably have suspected that the result would print as `4294967294`?\n\n##### Exception\n\nUse unsigned types if you really want modular arithmetic - add\ncomments as necessary noting the reliance on overflow behavior, as such code\nis going to be surprising for many programmers.\n\n##### Example\n\nThe standard library uses unsigned types for subscripts.\nThe built-in array uses signed types for subscripts.\nThis makes surprises (and bugs) inevitable.\n\n    int a[10];\n    for (int i = 0; i < 10; ++i) a[i] = i;\n    vector<int> v(10);\n    // compares signed to unsigned; some compilers warn, but we should not\n    for (gsl::index i = 0; i < v.size(); ++i) v[i] = i;\n\n    int a2[-2];         // error: negative size\n\n    // OK, but the number of ints (4294967294) is so large that we should get an exception\n    vector<int> v2(-2);\n\n Use `gsl::index` for subscripts; [see ES.107](#res-subscripts).\n\n##### Enforcement\n\n* Flag mixed signed and unsigned arithmetic\n* Flag results of unsigned arithmetic assigned to or printed as signed.\n* Flag negative literals (e.g. `-2`) used as container subscripts.\n* (To avoid noise) Do not flag on a mixed signed/unsigned comparison where one of the arguments is `sizeof` or a call to container `.size()` and the other is `ptrdiff_t`.\n\n\n### <a name=\"res-overflow\"></a>ES.103: Don't overflow\n\n##### Reason\n\nOverflow usually makes your numeric algorithm meaningless.\nIncrementing a value beyond a maximum value can lead to memory corruption and undefined behavior.\n\n##### Example, bad\n\n    int a[10];\n    a[10] = 7;   // bad, array bounds overflow\n\n    for (int n = 0; n <= 10; ++n)\n        a[n] = 9;   // bad, array bounds overflow\n\n##### Example, bad\n\n    int n = numeric_limits<int>::max();\n    int m = n + 1;   // bad, numeric overflow\n\n##### Example, bad\n\n    int area(int h, int w) { return h * w; }\n\n    auto a = area(10'000'000, 100'000'000);   // bad, numeric overflow\n\n##### Exception\n\nUse unsigned types if you really want modular arithmetic.\n\n**Alternative**: For critical applications that can afford some overhead, use a range-checked integer and/or floating-point type.\n\n##### Enforcement\n\n???\n\n### <a name=\"res-underflow\"></a>ES.104: Don't underflow\n\n##### Reason\n\nDecrementing a value beyond a minimum value can lead to memory corruption and undefined behavior.\n\n##### Example, bad\n\n    int a[10];\n    a[-2] = 7;   // bad\n\n    int n = 101;\n    while (n--)\n        a[n - 1] = 9;   // bad (twice)\n\n##### Exception\n\nUse unsigned types if you really want modular arithmetic.\n\n##### Enforcement\n\n???\n\n### <a name=\"res-zero\"></a>ES.105: Don't divide by integer zero\n\n##### Reason\n\nThe result is undefined and probably a crash.\n\n##### Note\n\nThis also applies to `%`.\n\n##### Example, bad\n\n    int divide(int a, int b)\n    {\n        // BAD, should be checked (e.g., in a precondition)\n        return a / b;\n    }\n\n##### Example, good\n\n    int divide(int a, int b)\n    {\n        // good, address via precondition (and replace with contracts once C++ gets them)\n        Expects(b != 0);\n        return a / b;\n    }\n\n    double divide(double a, double b)\n    {\n        // good, address via using double instead\n        return a / b;\n    }\n\n**Alternative**: For critical applications that can afford some overhead, use a range-checked integer and/or floating-point type.\n\n##### Enforcement\n\n* Flag division by an integral value that could be zero\n\n\n### <a name=\"res-nonnegative\"></a>ES.106: Don't try to avoid negative values by using `unsigned`\n\n##### Reason\n\nChoosing `unsigned` implies many changes to the usual behavior of integers, including modular arithmetic,\ncan suppress warnings related to overflow,\nand opens the door for errors related to signed/unsigned mixes.\nUsing `unsigned` doesn't actually eliminate the possibility of negative values.\n\n##### Example\n\n    unsigned int u1 = -2;   // Valid: the value of u1 is 4294967294\n    int i1 = -2;\n    unsigned int u2 = i1;   // Valid: the value of u2 is 4294967294\n    int i2 = u2;            // Valid: the value of i2 is -2\n\nThese problems with such (perfectly legal) constructs are hard to spot in real code and are the source of many real-world errors.\nConsider:\n\n    unsigned area(unsigned height, unsigned width) { return height*width; } // [see also](#ri-expects)\n    // ...\n    int height;\n    cin >> height;\n    auto a = area(height, 2);   // if the input is -2 a becomes 4294967292\n\nRemember that `-1` when assigned to an `unsigned int` becomes the largest `unsigned int`.\nAlso, since unsigned arithmetic is modular arithmetic the multiplication didn't overflow, it wrapped around.\n\n##### Example\n\n    unsigned max = 100000;    // \"accidental typo\", I mean to say 10'000\n    unsigned short x = 100;\n    while (x < max) x += 100; // infinite loop\n\nHad `x` been a signed `short`, we could have warned about the undefined behavior upon overflow.\n\n##### Alternatives\n\n* use signed integers and check for `x >= 0`\n* use a positive integer type\n* use an integer subrange type\n* `Assert(-1 < x)`\n\nFor example\n\n    struct Positive {\n        int val;\n        Positive(int x) :val{x} { Assert(0 < x); }\n        operator int() { return val; }\n    };\n\n    int f(Positive arg) { return arg; }\n\n    int r1 = f(2);\n    int r2 = f(-2);  // throws\n\n##### Note\n\n???\n\n##### Enforcement\n\nSee ES.100 Enforcements.\n\n\n### <a name=\"res-subscripts\"></a>ES.107: Don't use `unsigned` for subscripts, prefer `gsl::index`\n\n##### Reason\n\nTo avoid signed/unsigned confusion.\nTo enable better optimization.\nTo enable better error detection.\nTo avoid the pitfalls with `auto` and `int`.\n\n##### Example, bad\n\n    vector<int> vec = /*...*/;\n\n    for (int i = 0; i < vec.size(); i += 2)                    // might not be big enough\n        cout << vec[i] << '\\n';\n    for (unsigned i = 0; i < vec.size(); i += 2)               // risk wraparound\n        cout << vec[i] << '\\n';\n    for (auto i = 0; i < vec.size(); i += 2)                   // might not be big enough\n        cout << vec[i] << '\\n';\n    for (vector<int>::size_type i = 0; i < vec.size(); i += 2) // verbose\n        cout << vec[i] << '\\n';\n    for (auto i = vec.size()-1; i >= 0; i -= 2)                // bug\n        cout << vec[i] << '\\n';\n    for (int i = vec.size()-1; i >= 0; i -= 2)                 // might not be big enough\n        cout << vec[i] << '\\n';\n\n##### Example, good\n\n    vector<int> vec = /*...*/;\n\n    for (gsl::index i = 0; i < vec.size(); i += 2)             // ok\n        cout << vec[i] << '\\n';\n    for (gsl::index i = vec.size()-1; i >= 0; i -= 2)          // ok\n        cout << vec[i] << '\\n';\n\n##### Note\n\nThe built-in array allows signed subscripts.\nThe standard-library containers use unsigned subscripts.\nThus, no perfect and fully compatible solution is possible (unless and until the standard-library containers change to use signed subscripts someday in the future).\nGiven the known problems with unsigned and signed/unsigned mixtures, better stick to (signed) integers of a sufficient size, which is guaranteed by `gsl::index`.\n\n##### Example\n\n    template<typename T>\n    struct My_container {\n    public:\n        // ...\n        T& operator[](gsl::index i);    // not unsigned\n        // ...\n    };\n\n##### Example\n\n    ??? demonstrate improved code generation and potential for error detection ???\n\n##### Alternatives\n\nAlternatives for users\n\n* use algorithms\n* use range-for\n* use iterators/pointers\n\n##### Enforcement\n\n* Very tricky as long as the standard-library containers get it wrong.\n* (To avoid noise) Do not flag on a mixed signed/unsigned comparison where one of the arguments is `sizeof` or a call to container `.size()` and the other is `ptrdiff_t`.\n\n\n\n\n# <a name=\"s-performance\"></a>Per: Performance\n\n??? should this section be in the main guide???\n\nThis section contains rules for people who need high performance or low-latency.\nThat is, these are rules that relate to how to use as little time and as few resources as possible to achieve a task in a predictably short time.\nThe rules in this section are more restrictive and intrusive than what is needed for many (most) applications.\nDo not naïvely try to follow them in general code: achieving the goals of low latency requires extra work.\n\nPerformance rule summary:\n\n* [Per.1: Don't optimize without reason](#rper-reason)\n* [Per.2: Don't optimize prematurely](#rper-knuth)\n* [Per.3: Don't optimize something that's not performance critical](#rper-critical)\n* [Per.4: Don't assume that complicated code is necessarily faster than simple code](#rper-simple)\n* [Per.5: Don't assume that low-level code is necessarily faster than high-level code](#rper-low)\n* [Per.6: Don't make claims about performance without measurements](#rper-measure)\n* [Per.7: Design to enable optimization](#rper-efficiency)\n* [Per.10: Rely on the static type system](#rper-type)\n* [Per.11: Move computation from run time to compile time](#rper-comp)\n* [Per.12: Eliminate redundant aliases](#rper-alias)\n* [Per.13: Eliminate redundant indirections](#rper-indirect)\n* [Per.14: Minimize the number of allocations and deallocations](#rper-alloc)\n* [Per.15: Do not allocate on a critical branch](#rper-alloc0)\n* [Per.16: Use compact data structures](#rper-compact)\n* [Per.17: Declare the most used member of a time-critical struct first](#rper-struct)\n* [Per.18: Space is time](#rper-space)\n* [Per.19: Access memory predictably](#rper-access)\n* [Per.30: Avoid context switches on the critical path](#rper-context)\n\n### <a name=\"rper-reason\"></a>Per.1: Don't optimize without reason\n\n##### Reason\n\nIf there is no need for optimization, the main result of the effort will be more errors and higher maintenance costs.\n\n##### Note\n\nSome people optimize out of habit or because it's fun.\n\n???\n\n### <a name=\"rper-knuth\"></a>Per.2: Don't optimize prematurely\n\n##### Reason\n\nElaborately optimized code is usually larger and harder to change than unoptimized code.\n\n???\n\n### <a name=\"rper-critical\"></a>Per.3: Don't optimize something that's not performance critical\n\n##### Reason\n\nOptimizing a non-performance-critical part of a program has no effect on system performance.\n\n##### Note\n\nIf your program spends most of its time waiting for the web or for a human, optimization of in-memory computation is probably useless.\n\nPut another way: If your program spends 4% of its processing time doing\ncomputation A and 40% of its time doing computation B, a 50% improvement on A is\nonly as impactful as a 5% improvement on B. (If you don't even know how much\ntime is spent on A or B, see <a href=\"#rper-reason\">Per.1</a> and <a\nhref=\"#rper-knuth\">Per.2</a>.)\n\n### <a name=\"rper-simple\"></a>Per.4: Don't assume that complicated code is necessarily faster than simple code\n\n##### Reason\n\nSimple code can be very fast. Optimizers sometimes do marvels with simple code\n\n##### Example, good\n\n    // clear expression of intent, fast execution\n\n    vector<uint8_t> v(100000);\n\n    for (auto& c : v)\n        c = ~c;\n\n##### Example, bad\n\n    // intended to be faster, but is often slower\n\n    vector<uint8_t> v(100000);\n\n    for (size_t i = 0; i < v.size(); i += sizeof(uint64_t)) {\n        uint64_t& quad_word = *reinterpret_cast<uint64_t*>(&v[i]);\n        quad_word = ~quad_word;\n    }\n\n##### Note\n\n???\n\n???\n\n### <a name=\"rper-low\"></a>Per.5: Don't assume that low-level code is necessarily faster than high-level code\n\n##### Reason\n\nLow-level code sometimes inhibits optimizations. Optimizers sometimes do marvels with high-level code.\n\n##### Note\n\n???\n\n???\n\n### <a name=\"rper-measure\"></a>Per.6: Don't make claims about performance without measurements\n\n##### Reason\n\nThe field of performance is littered with myth and bogus folklore.\nModern hardware and optimizers defy naive assumptions; even experts are regularly surprised.\n\n##### Note\n\nGetting good performance measurements can be hard and require specialized tools.\n\n##### Note\n\nA few simple microbenchmarks using Unix `time` or the standard-library `<chrono>` can help dispel the most obvious myths.\nIf you can't measure your complete system accurately, at least try to measure a few of your key operations and algorithms.\nA profiler can help tell you which parts of your system are performance critical.\nOften, you will be surprised.\n\n???\n\n### <a name=\"rper-efficiency\"></a>Per.7: Design to enable optimization\n\n##### Reason\n\nBecause we often need to optimize the initial design.\nBecause a design that ignores the possibility of later improvement is hard to change.\n\n##### Example\n\nFrom the C (and C++) standard:\n\n    void qsort (void* base, size_t num, size_t size, int (*compar)(const void*, const void*));\n\nWhen did you even want to sort memory?\nReally, we sort sequences of elements, typically stored in containers.\nA call to `qsort` throws away much useful information (e.g., the element type), forces the user to repeat information\nalready known (e.g., the element size), and forces the user to write extra code (e.g., a function to compare `double`s).\nThis implies added work for the programmer, is error-prone, and deprives the compiler of information needed for optimization.\n\n    double data[100];\n    // ... fill a ...\n\n    // 100 chunks of memory of sizeof(double) starting at\n    // address data using the order defined by compare_doubles\n    qsort(data, 100, sizeof(double), compare_doubles);\n\nFrom the point of view of interface design, `qsort` throws away useful information.\n\nWe can do better (in C++98)\n\n    template<typename Iter>\n        void sort(Iter b, Iter e);  // sort [b:e)\n\n    sort(data, data + 100);\n\nHere, we use the compiler's knowledge about the size of the array, the type of elements, and how to compare `double`s.\n\nWith C++20, we can do better still\n\n    // sortable specifies that c must be a\n    // random-access sequence of elements comparable with <\n    void sort(sortable auto& c);\n\n    sort(c);\n\nThe key is to pass sufficient information for a good implementation to be chosen.\nIn this, the `sort` interfaces shown here still have a weakness:\nThey implicitly rely on the element type having less-than (`<`) defined.\nTo complete the interface, we need a second version that accepts a comparison criterion:\n\n    // compare elements of c using r\n    template<random_access_range R, class C> requires sortable<R, C>\n    void sort(R&& r, C c);\n\nThe standard-library specification of `sort` offers those two versions, and more.\n\n##### Note\n\nPremature optimization is said to be [the root of all evil](#rper-knuth), but that's not a reason to despise performance.\nIt is never premature to consider what makes a design amenable to improvement, and improved performance is a commonly desired improvement.\nAim to build a set of habits that by default results in efficient, maintainable, and optimizable code.\nIn particular, when you write a function that is not a one-off implementation detail, consider\n\n* Information passing:\nPrefer clean [interfaces](#s-interfaces) carrying sufficient information for later improvement of implementation.\nNote that information flows into and out of an implementation through the interfaces we provide.\n* Compact data: By default, [use compact data](#rper-compact), such as `std::vector` and [access it in a systematic fashion](#rper-access).\nIf you think you need a linked structure, try to craft the interface so that this structure isn't seen by users.\n* Function argument passing and return:\nDistinguish between mutable and non-mutable data.\nDon't impose a resource management burden on your users.\nDon't impose spurious run-time indirections on your users.\nUse [conventional ways](#rf-conventional) of passing information through an interface;\nunconventional and/or \"optimized\" ways of passing data can seriously complicate later reimplementation.\n* Abstraction:\nDon't overgeneralize; a design that tries to cater for every possible use (and misuse) and defers every design decision for later\n(using compile-time or run-time indirections) is usually a complicated, bloated, hard-to-understand mess.\nGeneralize from concrete examples, preserving performance as we generalize.\nDo not generalize based on mere speculation about future needs.\nThe ideal is zero-overhead generalization.\n* Libraries:\nUse libraries with good interfaces.\nIf no library is available build one yourself and imitate the interface style from a good library.\nThe [standard library](#sl-the-standard-library) is a good first place to look for inspiration.\n* Isolation:\nIsolate your code from messy and/or old-style code by providing an interface of your choosing to it.\nThis is sometimes called \"providing a wrapper\" for the useful/necessary but messy code.\nDon't let bad designs \"bleed into\" your code.\n\n##### Example\n\nConsider:\n\n    template<class ForwardIterator, class T>\n    bool binary_search(ForwardIterator first, ForwardIterator last, const T& val);\n\n`binary_search(begin(c), end(c), 7)` will tell you whether `7` is in `c` or not.\nHowever, it will not tell you where that `7` is or whether there are more than one `7`.\n\nSometimes, just passing the minimal amount of information back (here, `true` or `false`) is sufficient, but a good interface passes\nneeded information back to the caller. Therefore, the standard library also offers\n\n    template<class ForwardIterator, class T>\n    ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, const T& val);\n\n`lower_bound` returns an iterator to the first match if any, otherwise to the first element greater than `val`, or `last` if no such element is found.\n\nHowever, `lower_bound` still doesn't return enough information for all uses, so the standard library also offers\n\n    template<class ForwardIterator, class T>\n    pair<ForwardIterator, ForwardIterator>\n    equal_range(ForwardIterator first, ForwardIterator last, const T& val);\n\n`equal_range` returns a `pair` of iterators specifying the first and one beyond last match.\n\n    auto r = equal_range(begin(c), end(c), 7);\n    for (auto p = r.first; p != r.second; ++p)\n        cout << *p << '\\n';\n\nObviously, these three interfaces are implemented by the same basic code.\nThey are simply three ways of presenting the basic binary search algorithm to users,\nranging from the simplest (\"make simple things simple!\")\nto returning complete, but not always needed, information (\"don't hide useful information\").\nNaturally, crafting such a set of interfaces requires experience and domain knowledge.\n\n##### Note\n\nDo not simply craft the interface to match the first implementation and the first use case you think of.\nOnce your first initial implementation is complete, review it; once you deploy it, mistakes will be hard to remedy.\n\n##### Note\n\nA need for efficiency does not imply a need for [low-level code](#rper-low).\nHigh-level code isn't necessarily slow or bloated.\n\n##### Note\n\nThings have costs.\nDon't be paranoid about costs (modern computers really are very fast),\nbut have a rough idea of the order of magnitude of cost of what you use.\nFor example, have a rough idea of the cost of\na memory access,\na function call,\na string comparison,\na system call,\na disk access,\nand a message through a network.\n\n##### Note\n\nIf you can only think of one implementation, you probably don't have something for which you can devise a stable interface.\nMaybe, it is just an implementation detail - not every piece of code needs a stable interface - but pause and consider.\nOne question that can be useful is\n\"what interface would be needed if this operation should be implemented using multiple threads? be vectorized?\"\n\n##### Note\n\nThis rule does not contradict the [Don't optimize prematurely](#rper-knuth) rule.\nIt complements it, encouraging developers to enable later - appropriate and non-premature - optimization, if and where needed.\n\n##### Enforcement\n\nTricky.\nMaybe looking for `void*` function arguments will find examples of interfaces that hinder later optimization.\n\n### <a name=\"rper-type\"></a>Per.10: Rely on the static type system\n\n##### Reason\n\nType violations, weak types (e.g. `void*`s), and low-level code (e.g., manipulation of sequences as individual bytes) make the job of the optimizer much harder. Simple code often optimizes better than hand-crafted complex code.\n\n???\n\n### <a name=\"rper-comp\"></a>Per.11: Move computation from run time to compile time\n\n##### Reason\n\nTo decrease code size and run time.\nTo avoid data races by using constants.\nTo catch errors at compile time (and thus eliminate the need for error-handling code).\n\n##### Example\n\n    double square(double d) { return d*d; }\n    static double s2 = square(2);    // old-style: dynamic initialization\n\n    constexpr double ntimes(double d, int n)   // assume 0 <= n\n    {\n            double m = 1;\n            while (n--) m *= d;\n            return m;\n    }\n    constexpr double s3 {ntimes(2, 3)};  // modern-style: compile-time initialization\n\nCode like the initialization of `s2` isn't uncommon, especially for initialization that's a bit more complicated than `square()`.\nHowever, compared to the initialization of `s3` there are two problems:\n\n* we suffer the overhead of a function call at run time\n* `s2` just might be accessed by another thread before the initialization happens.\n\nNote: you can't have a data race on a constant.\n\n##### Example\n\nConsider a popular technique for providing a handle for storing small objects in the handle itself and larger ones on the heap.\n\n    constexpr int on_stack_max = 20;\n\n    template<typename T>\n    struct Scoped {     // store a T in Scoped\n            // ...\n        T obj;\n    };\n\n    template<typename T>\n    struct On_heap {    // store a T on the free store\n            // ...\n            T* objp;\n    };\n\n    template<typename T>\n    using Handle = typename std::conditional<(sizeof(T) <= on_stack_max),\n                        Scoped<T>,      // first alternative\n                        On_heap<T>      // second alternative\n                   >::type;\n\n    void f()\n    {\n        Handle<double> v1;                   // the double goes on the stack\n        Handle<std::array<double, 200>> v2;  // the array goes on the free store\n        // ...\n    }\n\nAssume that `Scoped` and `On_heap` provide compatible user interfaces.\nHere we compute the optimal type to use at compile time.\nThere are similar techniques for selecting the optimal function to call.\n\n##### Note\n\nThe ideal is *not* to try to execute everything at compile time.\nObviously, most computations depend on inputs, so they can't be moved to compile time,\nbut beyond that logical constraint is the fact that complex compile-time computation can seriously increase compile times\nand complicate debugging.\nIt is even possible to slow down code by compile-time computation.\nThis is admittedly rare, but by factoring out a general computation into separate optimal sub-calculations, it is possible to render the instruction cache less effective.\n\n##### Enforcement\n\n* Look for simple functions that might be constexpr (but are not).\n* Look for functions called with all constant-expression arguments.\n* Look for macros that could be constexpr.\n\n### <a name=\"rper-alias\"></a>Per.12: Eliminate redundant aliases\n\n???\n\n### <a name=\"rper-indirect\"></a>Per.13: Eliminate redundant indirections\n\n???\n\n### <a name=\"rper-alloc\"></a>Per.14: Minimize the number of allocations and deallocations\n\n???\n\n### <a name=\"rper-alloc0\"></a>Per.15: Do not allocate on a critical branch\n\n???\n\n### <a name=\"rper-compact\"></a>Per.16: Use compact data structures\n\n##### Reason\n\nPerformance is typically dominated by memory access times.\n\n???\n\n### <a name=\"rper-struct\"></a>Per.17: Declare the most used member of a time-critical struct first\n\n???\n\n### <a name=\"rper-space\"></a>Per.18: Space is time\n\n##### Reason\n\nPerformance is typically dominated by memory access times.\n\n???\n\n### <a name=\"rper-access\"></a>Per.19: Access memory predictably\n\n##### Reason\n\nPerformance is very sensitive to cache performance, and cache algorithms favor simple (usually linear) access to adjacent data.\n\n##### Example\n\n    int matrix[rows][cols];\n\n    // bad\n    for (int c = 0; c < cols; ++c)\n        for (int r = 0; r < rows; ++r)\n            sum += matrix[r][c];\n\n    // good\n    for (int r = 0; r < rows; ++r)\n        for (int c = 0; c < cols; ++c)\n            sum += matrix[r][c];\n\n### <a name=\"rper-context\"></a>Per.30: Avoid context switches on the critical path\n\n???\n\n# <a name=\"s-concurrency\"></a>CP: Concurrency and parallelism\n\nWe often want our computers to do many tasks at the same time (or at least appear to do them at the same time).\nThe reasons for doing so vary (e.g., waiting for many events using only a single processor, processing many data streams simultaneously, or utilizing many hardware facilities)\nand so do the basic facilities for expressing concurrency and parallelism.\nHere, we articulate principles and rules for using the ISO standard C++ facilities for expressing basic concurrency and parallelism.\n\nThreads are the machine-level foundation for concurrent and parallel programming.\nThreads allow running multiple sections of a program independently, while sharing\nthe same memory. Concurrent programming is tricky,\nbecause protecting shared data between threads is easier said than done.\nMaking existing single-threaded code execute concurrently can be\nas trivial as adding `std::async` or `std::thread` strategically, or it can\nnecessitate a full rewrite, depending on whether the original code was written\nin a thread-friendly way.\n\nThe concurrency/parallelism rules in this document are designed with three goals\nin mind:\n\n* To help in writing code that is amenable to being used in a threaded\n  environment\n* To show clean, safe ways to use the threading primitives offered by the\n  standard library\n* To offer guidance on what to do when concurrency and parallelism aren't giving\n  the performance gains needed\n\nIt is also important to note that concurrency in C++ is an unfinished\nstory. C++11 introduced many core concurrency primitives, C++14 and C++17 improved on\nthem, and there is much interest in making the writing of\nconcurrent programs in C++ even easier. We expect some of the library-related\nguidance here to change significantly over time.\n\nThis section needs a lot of work (obviously).\nPlease note that we start with rules for relative non-experts.\nReal experts must wait a bit;\ncontributions are welcome,\nbut please think about the majority of programmers who are struggling to get their concurrent programs correct and performant.\n\nConcurrency and parallelism rule summary:\n\n* [CP.1: Assume that your code will run as part of a multi-threaded program](#rconc-multi)\n* [CP.2: Avoid data races](#rconc-races)\n* [CP.3: Minimize explicit sharing of writable data](#rconc-data)\n* [CP.4: Think in terms of tasks, rather than threads](#rconc-task)\n* [CP.8: Don't try to use `volatile` for synchronization](#rconc-volatile)\n* [CP.9: Whenever feasible use tools to validate your concurrent code](#rconc-tools)\n\n**See also**:\n\n* [CP.con: Concurrency](#sscp-con)\n* [CP.coro: Coroutines](#sscp-coro)\n* [CP.par: Parallelism](#sscp-par)\n* [CP.mess: Message passing](#sscp-mess)\n* [CP.vec: Vectorization](#sscp-vec)\n* [CP.free: Lock-free programming](#sscp-free)\n* [CP.etc: Etc. concurrency rules](#sscp-etc)\n\n### <a name=\"rconc-multi\"></a>CP.1: Assume that your code will run as part of a multi-threaded program\n\n##### Reason\n\nIt's hard to be certain that concurrency isn't used now or won't be used sometime in the future.\nCode gets reused.\nLibraries not using threads might be used from some other part of a program that does use threads.\nNote that this rule applies most urgently to library code and least urgently to stand-alone applications.\nHowever, over time, code fragments can turn up in unexpected places.\n\n##### Example, bad\n\n    double cached_computation(int x)\n    {\n        // bad: these statics cause data races in multi-threaded usage\n        static int cached_x = 0.0;\n        static double cached_result = COMPUTATION_OF_ZERO;\n\n        if (cached_x != x) {\n            cached_x = x;\n            cached_result = computation(x);\n        }\n        return cached_result;\n    }\n\nAlthough `cached_computation` works perfectly in a single-threaded environment, in a multi-threaded environment the two `static` variables result in data races and thus undefined behavior.\n\n##### Example, good\n\n    struct ComputationCache {\n        int cached_x = 0;\n        double cached_result = COMPUTATION_OF_ZERO;\n\n        double compute(int x) {\n            if (cached_x != x) {\n                cached_x = x;\n                cached_result = computation(x);\n            }\n            return cached_result;\n        }\n    };\n\nHere the cache is stored as member data of a `ComputationCache` object, rather than as shared static state.\nThis refactoring essentially delegates the concern upward to the caller: a single-threaded program\nmight still choose to have one global `ComputationCache`, while a multi-threaded program might\nhave one `ComputationCache` instance per thread, or one per \"context\" for any definition of \"context.\"\nThe refactored function no longer attempts to manage the allocation of `cached_x`. In that sense,\nthis is an application of the Single Responsibility Principle.\n\nIn this specific example, refactoring for thread-safety also improved reusability in single-threaded\nprograms. It's not hard to imagine that a single-threaded program might want two `ComputationCache` instances\nfor use in different parts of the program, without having them overwrite each other's cached data.\n\nThere are several other ways one might add thread-safety to code written for a standard multi-threaded environment\n(that is, one where the only form of concurrency is `std::thread`):\n\n* Mark the state variables as `thread_local` instead of `static`.\n* Implement concurrency control, for example, protecting access to the two `static` variables with a `static std::mutex`.\n* Refuse to build and/or run in a multi-threaded environment.\n* Provide two implementations: one for single-threaded environments and another for multi-threaded environments.\n\n##### Exception\n\nCode that is never run in a multi-threaded environment.\n\nBe careful: there are many examples where code that was \"known\" to never run in a multi-threaded program\nwas run as part of a multi-threaded program, often years later.\nTypically, such programs lead to a painful effort to remove data races.\nTherefore, code that is never intended to run in a multi-threaded environment should be clearly labeled as such and ideally come with compile or run-time enforcement mechanisms to catch those usage bugs early.\n\n### <a name=\"rconc-races\"></a>CP.2: Avoid data races\n\n##### Reason\n\nUnless you do, nothing is guaranteed to work and subtle errors will persist.\n\n##### Note\n\nIn a nutshell, if two threads can access the same object concurrently (without synchronization), and at least one is a writer (performing a non-`const` operation), you have a data race.\nFor further information of how to use synchronization well to eliminate data races, please consult a good book about concurrency (see [Carefully study the literature](#rconc-literature)).\n\n##### Example, bad\n\nThere are many examples of data races that exist, some of which are running in\nproduction software at this very moment. One very simple example:\n\n    int get_id()\n    {\n      static int id = 1;\n      return id++;\n    }\n\nThe increment here is an example of a data race. This can go wrong in many ways,\nincluding:\n\n* Thread A loads the value of `id`, the OS context switches A out for some\n  period, during which other threads create hundreds of IDs. Thread A is then\n  allowed to run again, and `id` is written back to that location as A's read of\n  `id` plus one.\n* Thread A and B load `id` and increment it simultaneously.  They both get the\n  same ID.\n\nLocal static variables are a common source of data races.\n\n##### Example, bad:\n\n    void f(fstream& fs, regex pattern)\n    {\n        array<double, max> buf;\n        int sz = read_vec(fs, buf, max);            // read from fs into buf\n        gsl::span<double> s {buf};\n        // ...\n        auto h1 = async([&] { sort(std::execution::par, s); });     // spawn a task to sort\n        // ...\n        auto h2 = async([&] { return find_all(buf, sz, pattern); });   // spawn a task to find matches\n        // ...\n    }\n\nHere, we have a (nasty) data race on the elements of `buf` (`sort` will both read and write).\nAll data races are nasty.\nHere, we managed to get a data race on data on the stack.\nNot all data races are as easy to spot as this one.\n\n##### Example, bad:\n\n    // code not controlled by a lock\n\n    unsigned val;\n\n    if (val < 5) {\n        // ... other thread can change val here ...\n        switch (val) {\n        case 0: // ...\n        case 1: // ...\n        case 2: // ...\n        case 3: // ...\n        case 4: // ...\n        }\n    }\n\nNow, a compiler that does not know that `val` can change will  most likely implement that `switch` using a jump table with five entries.\nThen, a `val` outside the `[0..4]` range will cause a jump to an address that could be anywhere in the program, and execution would proceed there.\nReally, \"all bets are off\" if you get a data race.\nActually, it can be worse still: by looking at the generated code you might be able to determine where the stray jump will go for a given value;\nthis can be a security risk.\n\n##### Enforcement\n\nSome is possible, do at least something.\nThere are commercial and open-source tools that try to address this problem,\nbut be aware that solutions have costs and blind spots.\nStatic tools often have many false positives and run-time tools often have a significant cost.\nWe hope for better tools.\nUsing multiple tools can catch more problems than a single one.\n\nThere are other ways you can mitigate the chance of data races:\n\n* Avoid global data\n* Avoid `static` variables\n* More use of concrete types on the stack (and don't pass pointers around too much)\n* More use of immutable data (literals, `constexpr`, and `const`)\n\n### <a name=\"rconc-data\"></a>CP.3: Minimize explicit sharing of writable data\n\n##### Reason\n\nIf you don't share writable data, you can't have a data race.\nThe less sharing you do, the less chance you have to forget to synchronize access (and get data races).\nThe less sharing you do, the less chance you have to wait on a lock (so performance can improve).\n\n##### Example\n\n    bool validate(const vector<Reading>&);\n    Graph<Temp_node> temperature_gradients(const vector<Reading>&);\n    Image altitude_map(const vector<Reading>&);\n    // ...\n\n    void process_readings(const vector<Reading>& surface_readings)\n    {\n        auto h1 = async([&] { if (!validate(surface_readings)) throw Invalid_data{}; });\n        auto h2 = async([&] { return temperature_gradients(surface_readings); });\n        auto h3 = async([&] { return altitude_map(surface_readings); });\n        // ...\n        h1.get();\n        auto v2 = h2.get();\n        auto v3 = h3.get();\n        // ...\n    }\n\nWithout those `const`s, we would have to review every asynchronously invoked function for potential data races on `surface_readings`.\nMaking `surface_readings` be `const` (with respect to this function) allows reasoning using only the function body.\n\n##### Note\n\nImmutable data can be safely and efficiently shared.\nNo locking is needed: You can't have a data race on a constant.\nSee also [CP.mess: Message Passing](#sscp-mess) and [CP.31: prefer pass by value](#rconc-data-by-value).\n\n##### Enforcement\n\n???\n\n\n### <a name=\"rconc-task\"></a>CP.4: Think in terms of tasks, rather than threads\n\n##### Reason\n\nA `thread` is an implementation concept, a way of thinking about the machine.\nA task is an application notion, something you'd like to do, preferably concurrently with other tasks.\nApplication concepts are easier to reason about.\n\n##### Example\n\n    void some_fun(const std::string& msg)\n    {\n        std::thread publisher([=] { std::cout << msg; });      // bad: less expressive\n                                                               //      and more error-prone\n        auto pubtask = std::async([=] { std::cout << msg; });  // OK\n        // ...\n        publisher.join();\n    }\n\n##### Note\n\nWith the exception of `async()`, the standard-library facilities are low-level, machine-oriented, threads-and-lock level.\nThis is a necessary foundation, but we have to try to raise the level of abstraction: for productivity, for reliability, and for performance.\nThis is a potent argument for using higher level, more applications-oriented libraries (if possible, built on top of standard-library facilities).\n\n##### Enforcement\n\n???\n\n### <a name=\"rconc-volatile\"></a>CP.8: Don't try to use `volatile` for synchronization\n\n##### Reason\n\nIn C++, unlike some other languages, `volatile` does not provide atomicity, does not synchronize between threads,\nand does not prevent instruction reordering (neither compiler nor hardware).\nIt simply has nothing to do with concurrency.\n\n##### Example, bad:\n\n    int free_slots = max_slots; // current source of memory for objects\n\n    Pool* use()\n    {\n        if (int n = free_slots--) return &pool[n];\n    }\n\nHere we have a problem:\nThis is perfectly good code in a single-threaded program, but have two threads execute this and\nthere is a race condition on `free_slots` so that two threads might get the same value and `free_slots`.\nThat's (obviously) a bad data race, so people trained in other languages might try to fix it like this:\n\n    volatile int free_slots = max_slots; // current source of memory for objects\n\n    Pool* use()\n    {\n        if (int n = free_slots--) return &pool[n];\n    }\n\nThis has no effect on synchronization: The data race is still there!\n\nThe C++ mechanism for this is `atomic` types:\n\n    atomic<int> free_slots = max_slots; // current source of memory for objects\n\n    Pool* use()\n    {\n        if (int n = free_slots--) return &pool[n];\n    }\n\nNow the `--` operation is atomic,\nrather than a read-increment-write sequence where another thread might get in-between the individual operations.\n\n##### Alternative\n\nUse `atomic` types where you might have used `volatile` in some other language.\nUse a `mutex` for more complicated examples.\n\n##### See also\n\n[(rare) proper uses of `volatile`](#rconc-volatile2)\n\n### <a name=\"rconc-tools\"></a>CP.9: Whenever feasible use tools to validate your concurrent code\n\nExperience shows that concurrent code is exceptionally hard to get right\nand that compile-time checking, run-time checks, and testing are less effective at finding concurrency errors\nthan they are at finding errors in sequential code.\nSubtle concurrency errors can have dramatically bad effects, including memory corruption, deadlocks, and security vulnerabilities.\n\n##### Example\n\n    ???\n\n##### Note\n\nThread safety is challenging, often getting the better of experienced programmers: tooling is an important strategy to mitigate those risks.\nThere are many tools \"out there\", both commercial and open-source tools, both research and production tools.\nUnfortunately people's needs and constraints differ so dramatically that we cannot make specific recommendations,\nbut we can mention:\n\n* Static enforcement tools: both [clang](https://clang.llvm.org/docs/ThreadSafetyAnalysis.html)\nand some older versions of [GCC](https://gcc.gnu.org/wiki/ThreadSafetyAnnotation)\nhave some support for static annotation of thread safety properties.\nConsistent use of this technique turns many classes of thread-safety errors into compile-time errors.\nThe annotations are generally local (marking a particular data member as guarded by a particular mutex),\nand are usually easy to learn. However, as with many static tools, it can often present false negatives;\ncases that should have been caught but were allowed.\n\n* dynamic enforcement tools: Clang's [Thread Sanitizer](https://clang.llvm.org/docs/ThreadSanitizer.html) (aka TSAN)\nis a powerful example of dynamic tools: it changes the build and execution of your program to add bookkeeping on memory access,\nabsolutely identifying data races in a given execution of your binary.\nThe cost for this is both memory (5-10x in most cases) and CPU slowdown (2-20x).\nDynamic tools like this are best when applied to integration tests, canary pushes, or unit tests that operate on multiple threads.\nWorkload matters: When TSAN identifies a problem, it is effectively always an actual data race,\nbut it can only identify races seen in a given execution.\n\n##### Enforcement\n\nIt is up to an application builder to choose which support tools are valuable for a particular application.\n\n## <a name=\"sscp-con\"></a>CP.con: Concurrency\n\nThis section focuses on relatively ad-hoc uses of multiple threads communicating through shared data.\n\n* For parallel algorithms, see [parallelism](#sscp-par)\n* For inter-task communication without explicit sharing, see [messaging](#sscp-mess)\n* For vector parallel code, see [vectorization](#sscp-vec)\n* For lock-free programming, see [lock free](#sscp-free)\n\nConcurrency rule summary:\n\n* [CP.20: Use RAII, never plain `lock()`/`unlock()`](#rconc-raii)\n* [CP.21: Use `std::lock()` or `std::scoped_lock` to acquire multiple `mutex`es](#rconc-lock)\n* [CP.22: Never call unknown code while holding a lock (e.g., a callback)](#rconc-unknown)\n* [CP.23: Think of a joining `thread` as a scoped container](#rconc-join)\n* [CP.24: Think of a `thread` as a global container](#rconc-detach)\n* [CP.25: Prefer `gsl::joining_thread` over `std::thread`](#rconc-joining_thread)\n* [CP.26: Don't `detach()` a thread](#rconc-detached_thread)\n* [CP.31: Pass small amounts of data between threads by value, rather than by reference or pointer](#rconc-data-by-value)\n* [CP.32: To share ownership between unrelated `thread`s use `shared_ptr`](#rconc-shared)\n* [CP.40: Minimize context switching](#rconc-switch)\n* [CP.41: Minimize thread creation and destruction](#rconc-create)\n* [CP.42: Don't `wait` without a condition](#rconc-wait)\n* [CP.43: Minimize time spent in a critical section](#rconc-time)\n* [CP.44: Remember to name your `lock_guard`s and `unique_lock`s](#rconc-name)\n* [CP.50: Define a `mutex` together with the data it guards. Use `synchronized_value<T>` where possible](#rconc-mutex)\n* ??? when to use a spinlock\n* ??? when to use `try_lock()`\n* ??? when to prefer `lock_guard` over `unique_lock`\n* ??? Time multiplexing\n* ??? when/how to use `new thread`\n\n### <a name=\"rconc-raii\"></a>CP.20: Use RAII, never plain `lock()`/`unlock()`\n\n##### Reason\n\nAvoids nasty errors from unreleased locks.\n\n##### Example, bad\n\n    mutex mtx;\n\n    void do_stuff()\n    {\n        mtx.lock();\n        // ... do stuff ...\n        mtx.unlock();\n    }\n\nSooner or later, someone will forget the `mtx.unlock()`, place a `return` in the `... do stuff ...`, throw an exception, or something.\n\n    mutex mtx;\n\n    void do_stuff()\n    {\n        unique_lock<mutex> lck {mtx};\n        // ... do stuff ...\n    }\n\n##### Enforcement\n\nFlag calls of member `lock()` and `unlock()`.  ???\n\n\n### <a name=\"rconc-lock\"></a>CP.21: Use `std::lock()` or `std::scoped_lock` to acquire multiple `mutex`es\n\n##### Reason\n\nTo avoid deadlocks on multiple `mutex`es.\n\n##### Example\n\nThis is asking for deadlock:\n\n    // thread 1\n    lock_guard<mutex> lck1(m1);\n    lock_guard<mutex> lck2(m2);\n\n    // thread 2\n    lock_guard<mutex> lck2(m2);\n    lock_guard<mutex> lck1(m1);\n\nInstead, use `lock()`:\n\n    // thread 1\n    lock(m1, m2);\n    lock_guard<mutex> lck1(m1, adopt_lock);\n    lock_guard<mutex> lck2(m2, adopt_lock);\n\n    // thread 2\n    lock(m2, m1);\n    lock_guard<mutex> lck2(m2, adopt_lock);\n    lock_guard<mutex> lck1(m1, adopt_lock);\n\nor (better, but C++17 only):\n\n    // thread 1\n    scoped_lock<mutex, mutex> lck1(m1, m2);\n\n    // thread 2\n    scoped_lock<mutex, mutex> lck2(m2, m1);\n\nHere, the writers of `thread1` and `thread2` are still not agreeing on the order of the `mutex`es, but order no longer matters.\n\n##### Note\n\nIn real code, `mutex`es are rarely named to conveniently remind the programmer of an intended relation and intended order of acquisition.\nIn real code, `mutex`es are not always conveniently acquired on consecutive lines.\n\n##### Note\n\nIn C++17 it's possible to write plain\n\n    lock_guard lck1(m1, adopt_lock);\n\nand have the `mutex` type deduced.\n\n##### Enforcement\n\nDetect the acquisition of multiple `mutex`es.\nThis is undecidable in general, but catching common simple examples (like the one above) is easy.\n\n\n### <a name=\"rconc-unknown\"></a>CP.22: Never call unknown code while holding a lock (e.g., a callback)\n\n##### Reason\n\nIf you don't know what a piece of code does, you are risking deadlock.\n\n##### Example\n\n    void do_this(Foo* p)\n    {\n        lock_guard<mutex> lck {my_mutex};\n        // ... do something ...\n        p->act(my_data);\n        // ...\n    }\n\nIf you don't know what `Foo::act` does (maybe it is a virtual function invoking a derived class member of a class not yet written),\nit might call `do_this` (recursively) and cause a deadlock on `my_mutex`.\nMaybe it will lock on a different mutex and not return in a reasonable time, causing delays to any code calling `do_this`.\n\n##### Example\n\nA common example of the \"calling unknown code\" problem is a call to a function that tries to gain locked access to the same object.\nSuch problem can often be solved by using a `recursive_mutex`. For example:\n\n    recursive_mutex my_mutex;\n\n    template<typename Action>\n    void do_something(Action f)\n    {\n        unique_lock<recursive_mutex> lck {my_mutex};\n        // ... do something ...\n        f(this);    // f will do something to *this\n        // ...\n    }\n\nIf, as it is likely, `f()` invokes operations on `*this`, we must make sure that the object's invariant holds before the call.\n\n##### Enforcement\n\n* Flag calling a virtual function with a non-recursive `mutex` held\n* Flag calling a callback with a non-recursive `mutex` held\n\n\n### <a name=\"rconc-join\"></a>CP.23: Think of a joining `thread` as a scoped container\n\n##### Reason\n\nTo maintain pointer safety and avoid leaks, we need to consider what pointers are used by a `thread`.\nIf a `thread` joins, we can safely pass pointers to objects in the scope of the `thread` and its enclosing scopes.\n\n##### Example\n\n    void f(int* p)\n    {\n        // ...\n        *p = 99;\n        // ...\n    }\n    int glob = 33;\n\n    void some_fct(int* p)\n    {\n        int x = 77;\n        joining_thread t0(f, &x);           // OK\n        joining_thread t1(f, p);            // OK\n        joining_thread t2(f, &glob);        // OK\n        auto q = make_unique<int>(99);\n        joining_thread t3(f, q.get());      // OK\n        // ...\n    }\n\nA `gsl::joining_thread` is a `std::thread` with a destructor that joins and that cannot be `detached()`.\nBy \"OK\" we mean that the object will be in scope (\"live\") for as long as a `thread` can use the pointer to it.\nThe fact that `thread`s run concurrently doesn't affect the lifetime or ownership issues here;\nthese `thread`s can be seen as just a function object called from `some_fct`.\n\n##### Enforcement\n\nEnsure that `joining_thread`s don't `detach()`.\nAfter that, the usual lifetime and ownership (for local objects) enforcement applies.\n\n### <a name=\"rconc-detach\"></a>CP.24: Think of a `thread` as a global container\n\n##### Reason\n\nTo maintain pointer safety and avoid leaks, we need to consider what pointers are used by a `thread`.\nIf a `thread` is detached, we can safely pass pointers to static and free store objects (only).\n\n##### Example\n\n    void f(int* p)\n    {\n        // ...\n        *p = 99;\n        // ...\n    }\n\n    int glob = 33;\n\n    void some_fct(int* p)\n    {\n        int x = 77;\n        std::thread t0(f, &x);           // bad\n        std::thread t1(f, p);            // bad\n        std::thread t2(f, &glob);        // OK\n        auto q = make_unique<int>(99);\n        std::thread t3(f, q.get());      // bad\n        // ...\n        t0.detach();\n        t1.detach();\n        t2.detach();\n        t3.detach();\n        // ...\n    }\n\nBy \"OK\" we mean that the object will be in scope (\"live\") for as long as a `thread` can use the pointers to it.\nBy \"bad\" we mean that a `thread` might use a pointer after the pointed-to object is destroyed.\nThe fact that `thread`s run concurrently doesn't affect the lifetime or ownership issues here;\nthese `thread`s can be seen as just a function object called from `some_fct`.\n\n##### Note\n\nEven objects with static storage duration can be problematic if used from detached threads: if the\nthread continues until the end of the program, it might be running concurrently with the destruction\nof objects with static storage duration, and thus accesses to such objects might race.\n\n##### Note\n\nThis rule is redundant if you [don't `detach()`](#rconc-detached_thread) and [use `gsl::joining_thread`](#rconc-joining_thread).\nHowever, converting code to follow those guidelines could be difficult and even impossible for third-party libraries.\nIn such cases, the rule becomes essential for lifetime safety and type safety.\n\n\nIn general, it is undecidable whether a `detach()` is executed for a `thread`, but simple common cases are easily detected.\nIf we cannot prove that a `thread` does not `detach()`, we must assume that it does and that it outlives the scope in which it was constructed;\nafter that, the usual lifetime and ownership (for global objects) enforcement applies.\n\n##### Enforcement\n\nFlag attempts to pass local variables to a thread that might `detach()`.\n\n### <a name=\"rconc-joining_thread\"></a>CP.25: Prefer `gsl::joining_thread` over `std::thread`\n\n##### Reason\n\nA `joining_thread` is a thread that joins at the end of its scope.\nDetached threads are hard to monitor.\nIt is harder to ensure absence of errors in detached threads (and potentially detached threads).\n\n##### Example, bad\n\n    void f() { std::cout << \"Hello \"; }\n\n    struct F {\n        void operator()() const { std::cout << \"parallel world \"; }\n    };\n\n    int main()\n    {\n        std::thread t1{f};      // f() executes in separate thread\n        std::thread t2{F()};    // F()() executes in separate thread\n    }  // spot the bugs\n\n##### Example\n\n    void f() { std::cout << \"Hello \"; }\n\n    struct F {\n        void operator()() const { std::cout << \"parallel world \"; }\n    };\n\n    int main()\n    {\n        std::thread t1{f};      // f() executes in separate thread\n        std::thread t2{F()};    // F()() executes in separate thread\n\n        t1.join();\n        t2.join();\n    }  // one bad bug left\n\n##### Note\n\nMake \"immortal threads\" globals, put them in an enclosing scope, or put them on the free store rather than `detach()`.\n[Don't `detach`](#rconc-detached_thread).\n\n##### Note\n\nBecause of old code and third party libraries using `std::thread`, this rule can be hard to introduce.\n\n##### Enforcement\n\nFlag uses of `std::thread`:\n\n* Suggest use of `gsl::joining_thread` or C++20 `std::jthread`.\n* Suggest [\"exporting ownership\"](#rconc-detached_thread) to an enclosing scope if it detaches.\n* Warn if it is not obvious whether a thread joins or detaches.\n\n### <a name=\"rconc-detached_thread\"></a>CP.26: Don't `detach()` a thread\n\n##### Reason\n\nOften, the need to outlive the scope of its creation is inherent in the `thread`s task,\nbut implementing that idea by `detach` makes it harder to monitor and communicate with the detached thread.\nIn particular, it is harder (though not impossible) to ensure that the thread completed as expected or lives for as long as expected.\n\n##### Example\n\n    void heartbeat();\n\n    void use()\n    {\n        std::thread t(heartbeat);             // don't join; heartbeat is meant to run forever\n        t.detach();\n        // ...\n    }\n\nThis is a reasonable use of a thread, for which `detach()` is commonly used.\nThere are problems, though.\nHow do we monitor the detached thread to see if it is alive?\nSomething might go wrong with the heartbeat, and losing a heartbeat can be very serious in a system for which it is needed.\nSo, we need to communicate with the heartbeat thread\n(e.g., through a stream of messages or notification events using a `condition_variable`).\n\nAn alternative, and usually superior solution is to control its lifetime by placing it in a scope outside its point of creation (or activation).\nFor example:\n\n    void heartbeat();\n\n    gsl::joining_thread t(heartbeat);             // heartbeat is meant to run \"forever\"\n\nThis heartbeat will (barring error, hardware problems, etc.) run for as long as the program does.\n\nSometimes, we need to separate the point of creation from the point of ownership:\n\n    void heartbeat();\n\n    unique_ptr<gsl::joining_thread> tick_tock {nullptr};\n\n    void use()\n    {\n        // heartbeat is meant to run as long as tick_tock lives\n        tick_tock = make_unique<gsl::joining_thread>(heartbeat);\n        // ...\n    }\n\n#### Enforcement\n\nFlag `detach()`.\n\n\n### <a name=\"rconc-data-by-value\"></a>CP.31: Pass small amounts of data between threads by value, rather than by reference or pointer\n\n##### Reason\n\nA small amount of data is cheaper to copy and access than to share it using some locking mechanism.\nCopying naturally gives unique ownership (simplifies code) and eliminates the possibility of data races.\n\n##### Note\n\nDefining \"small amount\" precisely is impossible.\n\n##### Example\n\n    string modify1(string);\n    void modify2(string&);\n\n    void fct(string& s)\n    {\n        auto res = async(modify1, s);\n        async(modify2, s);\n    }\n\nThe call of `modify1` involves copying two `string` values; the call of `modify2` does not.\nOn the other hand, the implementation of `modify1` is exactly as we would have written it for single-threaded code,\nwhereas the implementation of `modify2` will need some form of locking to avoid data races.\nIf the string is short (say 10 characters), the call of `modify1` can be surprisingly fast;\nessentially all the cost is in the `thread` switch. If the string is long (say 1,000,000 characters), copying it twice\nis probably not a good idea.\n\nNote that this argument has nothing to do with `async` as such. It applies equally to considerations about whether to use\nmessage passing or shared memory.\n\n##### Enforcement\n\n???\n\n\n### <a name=\"rconc-shared\"></a>CP.32: To share ownership between unrelated `thread`s use `shared_ptr`\n\n##### Reason\n\nIf threads are unrelated (that is, not known to be in the same scope or one within the lifetime of the other)\nand they need to share free store memory that needs to be deleted, a `shared_ptr` (or equivalent) is the only\nsafe way to ensure proper deletion.\n\n##### Example\n\n    ???\n\n##### Note\n\n* A static object (e.g. a global) can be shared because it is not owned in the sense that some thread is responsible for its deletion.\n* An object on free store that is never to be deleted can be shared.\n* An object owned by one thread can be safely shared with another as long as that second thread doesn't outlive the owner.\n\n##### Enforcement\n\n???\n\n\n### <a name=\"rconc-switch\"></a>CP.40: Minimize context switching\n\n##### Reason\n\nContext switches are expensive.\n\n##### Example\n\n    ???\n\n##### Enforcement\n\n???\n\n\n### <a name=\"rconc-create\"></a>CP.41: Minimize thread creation and destruction\n\n##### Reason\n\nThread creation is expensive.\n\n##### Example\n\n    void worker(Message m)\n    {\n        // process\n    }\n\n    void dispatcher(istream& is)\n    {\n        for (Message m; is >> m; )\n            run_list.push_back(new thread(worker, m));\n    }\n\nThis spawns a `thread` per message, and the `run_list` is presumably managed to destroy those tasks once they are finished.\n\nInstead, we could have a set of pre-created worker threads processing the messages\n\n    Sync_queue<Message> work;\n\n    void dispatcher(istream& is)\n    {\n        for (Message m; is >> m; )\n            work.put(m);\n    }\n\n    void worker()\n    {\n        for (Message m; m = work.get(); ) {\n            // process\n        }\n    }\n\n    void workers()  // set up worker threads (specifically 4 worker threads)\n    {\n        joining_thread w1 {worker};\n        joining_thread w2 {worker};\n        joining_thread w3 {worker};\n        joining_thread w4 {worker};\n    }\n\n##### Note\n\nIf your system has a good thread pool, use it.\nIf your system has a good message queue, use it.\n\n##### Enforcement\n\n???\n\n\n### <a name=\"rconc-wait\"></a>CP.42: Don't `wait` without a condition\n\n##### Reason\n\nA `wait` without a condition can miss a wakeup or wake up simply to find that there is no work to do.\n\n##### Example, bad\n\n    std::condition_variable cv;\n    std::mutex mx;\n\n    void thread1()\n    {\n        while (true) {\n            // do some work ...\n            std::unique_lock<std::mutex> lock(mx);\n            cv.notify_one();    // wake other thread\n        }\n    }\n\n    void thread2()\n    {\n        while (true) {\n            std::unique_lock<std::mutex> lock(mx);\n            cv.wait(lock);    // might block forever\n            // do work ...\n        }\n    }\n\nHere, if some other `thread` consumes `thread1`'s notification, `thread2` can wait forever.\n\n##### Example\n\n    template<typename T>\n    class Sync_queue {\n    public:\n        void put(const T& val);\n        void put(T&& val);\n        void get(T& val);\n    private:\n        mutex mtx;\n        condition_variable cond;    // this controls access\n        list<T> q;\n    };\n\n    template<typename T>\n    void Sync_queue<T>::put(const T& val)\n    {\n        lock_guard<mutex> lck(mtx);\n        q.push_back(val);\n        cond.notify_one();\n    }\n\n    template<typename T>\n    void Sync_queue<T>::get(T& val)\n    {\n        unique_lock<mutex> lck(mtx);\n        cond.wait(lck, [this] { return !q.empty(); });    // prevent spurious wakeup\n        val = q.front();\n        q.pop_front();\n    }\n\nNow if the queue is empty when a thread executing `get()` wakes up (e.g., because another thread has gotten to `get()` before it),\nit will immediately go back to sleep, waiting.\n\n##### Enforcement\n\nFlag all `wait`s without conditions.\n\n\n### <a name=\"rconc-time\"></a>CP.43: Minimize time spent in a critical section\n\n##### Reason\n\nThe less time is spent with a `mutex` taken, the less chance that another `thread` has to wait,\nand `thread` suspension and resumption are expensive.\n\n##### Example\n\n    void do_something() // bad\n    {\n        unique_lock<mutex> lck(my_lock);\n        do0();  // preparation: does not need lock\n        do1();  // transaction: needs locking\n        do2();  // cleanup: does not need locking\n    }\n\nHere, we are holding the lock for longer than necessary:\nWe should not have taken the lock before we needed it and should have released it again before starting the cleanup.\nWe could rewrite this to\n\n    void do_something() // bad\n    {\n        do0();  // preparation: does not need lock\n        my_lock.lock();\n        do1();  // transaction: needs locking\n        my_lock.unlock();\n        do2();  // cleanup: does not need locking\n    }\n\nBut that compromises safety and violates the [use RAII](#rconc-raii) rule.\nInstead, add a block for the critical section:\n\n    void do_something() // OK\n    {\n        do0();  // preparation: does not need lock\n        {\n            unique_lock<mutex> lck(my_lock);\n            do1();  // transaction: needs locking\n        }\n        do2();  // cleanup: does not need locking\n    }\n\n##### Enforcement\n\nImpossible in general.\nFlag \"naked\" `lock()` and `unlock()`.\n\n\n### <a name=\"rconc-name\"></a>CP.44: Remember to name your `lock_guard`s and `unique_lock`s\n\n##### Reason\n\nAn unnamed local object is a temporary that immediately goes out of scope.\n\n##### Example\n\n    // global mutexes\n    mutex m1;\n    mutex m2;\n\n    void f()\n    {\n        unique_lock<mutex>(m1); // (A)\n        lock_guard<mutex> {m2}; // (B)\n        // do work in critical section ...\n    }\n\nThis looks innocent enough, but it isn't. At (A), `m1` is a default-constructed\nlocal `unique_lock`, which shadows the global `::m1` (and does not lock it).\nAt (B) an unnamed temporary `lock_guard` is constructed and locks `::m2`,\nbut immediately goes out of scope and unlocks `::m2` again.\nFor the rest of the function `f()` neither mutex is locked.\n\n##### Enforcement\n\nFlag all unnamed `lock_guard`s and `unique_lock`s.\n\n\n\n### <a name=\"rconc-mutex\"></a>CP.50: Define a `mutex` together with the data it guards. Use `synchronized_value<T>` where possible\n\n##### Reason\n\nIt should be obvious to a reader that the data is to be guarded and how. This decreases the chance of the wrong mutex being locked, or the mutex not being locked.\n\nUsing a `synchronized_value<T>` ensures that the data has a mutex, and the right mutex is locked when the data is accessed.\nSee the [WG21 proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p0290r4.html) to add `synchronized_value` to a future TS or revision of the C++ standard.\n\n##### Example\n\n    struct Record {\n        std::mutex m;   // take this mutex before accessing other members\n        // ...\n    };\n\n    class MyClass {\n        struct DataRecord {\n           // ...\n        };\n        synchronized_value<DataRecord> data; // Protect the data with a mutex\n    };\n\n##### Enforcement\n\n??? Possible?\n\n\n## <a name=\"sscp-coro\"></a>CP.coro: Coroutines\n\nThis section focuses on uses of coroutines.\n\nCoroutine rule summary:\n\n* [CP.51: Do not use capturing lambdas that are coroutines](#rcoro-capture)\n* [CP.52: Do not hold locks or other synchronization primitives across suspension points](#rcoro-locks)\n* [CP.53: Parameters to coroutines should not be passed by reference](#rcoro-reference-parameters)\n\n### <a name=\"rcoro-capture\"></a>CP.51: Do not use capturing lambdas that are coroutines\n\n##### Reason\n\nUsage patterns that are correct with normal lambdas are hazardous with coroutine lambdas. The obvious pattern of capturing variables will result in accessing freed memory after the first suspension point, even for refcounted smart pointers and copyable types.\n\nA lambda results in a closure object with storage, often on the stack, that will go out of scope at some point.  When the closure object goes out of scope the captures will also go out of scope.  Normal lambdas will have finished executing by this time so it is not a problem.  Coroutine lambdas may resume from suspension after the closure object has destructed and at that point all captures will be use-after-free memory access.\n\n##### Example, Bad\n\n    int value = get_value();\n    std::shared_ptr<Foo> sharedFoo = get_foo();\n    {\n      const auto lambda = [value, sharedFoo]() -> std::future<void>\n      {\n        co_await something();\n        // \"sharedFoo\" and \"value\" have already been destroyed\n        // the \"shared\" pointer didn't accomplish anything\n      };\n      lambda();\n    } // the lambda closure object has now gone out of scope\n\n##### Example, Better\n\n    int value = get_value();\n    std::shared_ptr<Foo> sharedFoo = get_foo();\n    {\n      // take as by-value parameter instead of as a capture\n      const auto lambda = [](auto sharedFoo, auto value) -> std::future<void>\n      {\n        co_await something();\n        // sharedFoo and value are still valid at this point\n      };\n      lambda(sharedFoo, value);\n    } // the lambda closure object has now gone out of scope\n\n##### Example, Best\n\nUse a function for coroutines.\n\n    std::future<void> Class::do_something(int value, std::shared_ptr<Foo> sharedFoo)\n    {\n      co_await something();\n      // sharedFoo and value are still valid at this point\n    }\n\n    void SomeOtherFunction()\n    {\n      int value = get_value();\n      std::shared_ptr<Foo> sharedFoo = get_foo();\n      do_something(value, sharedFoo);\n    }\n\n##### Enforcement\n\nFlag a lambda that is a coroutine and has a non-empty capture list.\n\n\n### <a name=\"rcoro-locks\"></a>CP.52: Do not hold locks or other synchronization primitives across suspension points\n\n##### Reason\n\nThis pattern creates a significant risk of deadlocks.  Some types of waits will allow the current thread to perform additional work until the asynchronous operation has completed. If the thread holding the lock performs work that requires the same lock then it will deadlock because it is trying to acquire a lock that it is already holding.\n\nIf the coroutine completes on a different thread from the thread that acquired the lock then that is undefined behavior.  Even with an explicit return to the original thread an exception might be thrown before coroutine resumes and the result will be that the lock guard is not destructed.\n\n##### Example, Bad\n\n    std::mutex g_lock;\n\n    std::future<void> Class::do_something()\n    {\n        std::lock_guard<std::mutex> guard(g_lock);\n        co_await something(); // DANGER: coroutine has suspended execution while holding a lock\n        co_await somethingElse();\n    }\n\n##### Example, Good\n\n    std::mutex g_lock;\n\n    std::future<void> Class::do_something()\n    {\n        {\n            std::lock_guard<std::mutex> guard(g_lock);\n            // modify data protected by lock\n        }\n        co_await something(); // OK: lock has been released before coroutine suspends\n        co_await somethingElse();\n    }\n\n\n##### Note\n\nThis pattern is also bad for performance. When a suspension point is reached, such as co_await, execution of the current function stops and other code begins to run. It may be a long period of time before the coroutine resumes. For that entire duration the lock will be held and cannot be acquired by other threads to perform work.\n\n##### Enforcement\n\nFlag all lock guards that are not destructed before a coroutine suspends.\n\n### <a name=\"rcoro-reference-parameters\"></a>CP.53: Parameters to coroutines should not be passed by reference\n\n##### Reason\n\nOnce a coroutine reaches the first suspension point, such as a co_await, the synchronous portion returns. After that point any parameters passed by reference are dangling. Any usage beyond that is undefined behavior which may include writing to freed memory.\n\n##### Example, Bad\n\n    std::future<int> Class::do_something(const std::shared_ptr<int>& input)\n    {\n        co_await something();\n\n        // DANGER: the reference to input may no longer be valid and may be freed memory\n        co_return *input + 1;\n    }\n\n##### Example, Good\n\n    std::future<int> Class::do_something(std::shared_ptr<int> input)\n    {\n        co_await something();\n        co_return *input + 1; // input is a copy that is still valid here\n    }\n\n##### Note\n\nThis problem does not apply to reference parameters that are only accessed before the first suspension point. Subsequent changes to the function may add or move suspension points which would reintroduce this class of bug. Some types of coroutines have the suspension point before the first line of code in the coroutine executes, in which case reference parameters are always unsafe.  It is safer to always pass by value because the copied parameter will live in the coroutine frame that is safe to access throughout the coroutine.\n\n##### Note\n\nThe same danger applies to output parameters.  [F.20: For \"out\" output values, prefer return values to output parameters](#rf-out) discourages output parameters.  Coroutines should avoid them entirely.\n\n##### Enforcement\n\nFlag all reference parameters to a coroutine.\n\n## <a name=\"sscp-par\"></a>CP.par: Parallelism\n\nBy \"parallelism\" we refer to performing a task (more or less) simultaneously (\"in parallel with\") on many data items.\n\nParallelism rule summary:\n\n* ???\n* ???\n* Where appropriate, prefer the standard-library parallel algorithms\n* Use algorithms that are designed for parallelism, not algorithms with unnecessary dependency on linear evaluation\n\n\n\n## <a name=\"sscp-mess\"></a>CP.mess: Message passing\n\nThe standard-library facilities are quite low-level, focused on the needs of close-to-the-hardware critical programming using `thread`s, `mutex`es, `atomic` types, etc.\nMost people shouldn't work at this level: it's error-prone and development is slow.\nIf possible, use a higher level facility: messaging libraries, parallel algorithms, and vectorization.\nThis section looks at passing messages so that a programmer doesn't have to do explicit synchronization.\n\nMessage passing rules summary:\n\n* [CP.60: Use a `future` to return a value from a concurrent task](#rconc-future)\n* [CP.61: Use `async()` to spawn concurrent tasks](#rconc-async)\n* message queues\n* messaging libraries\n\n???? should there be a \"use X rather than `std::async`\" where X is something that would use a better specified thread pool?\n\n??? Is `std::async` worth using in light of future (and even existing, as libraries) parallelism facilities? What should the guidelines recommend if someone wants to parallelize, e.g., `std::accumulate` (with the additional precondition of commutativity), or merge sort?\n\n\n### <a name=\"rconc-future\"></a>CP.60: Use a `future` to return a value from a concurrent task\n\n##### Reason\n\nA `future` preserves the usual function call return semantics for asynchronous tasks.\nThere is no explicit locking and both correct (value) return and error (exception) return are handled simply.\n\n##### Example\n\n    ???\n\n##### Note\n\n???\n\n##### Enforcement\n\n???\n\n### <a name=\"rconc-async\"></a>CP.61: Use `async()` to spawn concurrent tasks\n\n##### Reason\n\nSimilar to [R.12](#rr-immediate-alloc), which tells you to avoid raw owning pointers, you should\nalso avoid raw threads and raw promises where possible. Use a factory function such as `std::async`,\nwhich handles spawning or reusing a thread without exposing raw threads to your own code.\n\n##### Example\n\n    int read_value(const std::string& filename)\n    {\n        std::ifstream in(filename);\n        in.exceptions(std::ifstream::failbit);\n        int value;\n        in >> value;\n        return value;\n    }\n\n    void async_example()\n    {\n        try {\n            std::future<int> f1 = std::async(read_value, \"v1.txt\");\n            std::future<int> f2 = std::async(read_value, \"v2.txt\");\n            std::cout << f1.get() + f2.get() << '\\n';\n        } catch (const std::ios_base::failure& fail) {\n            // handle exception here\n        }\n    }\n\n##### Note\n\nUnfortunately, `std::async` is not perfect. For example, it doesn't use a thread pool,\nwhich means that it might fail due to resource exhaustion, rather than queuing up your tasks\nto be executed later. However, even if you cannot use `std::async`, you should prefer to\nwrite your own `future`-returning factory function, rather than using raw promises.\n\n##### Example (bad)\n\nThis example shows two different ways to succeed at using `std::future`, but to fail\nat avoiding raw `std::thread` management.\n\n    void async_example()\n    {\n        std::promise<int> p1;\n        std::future<int> f1 = p1.get_future();\n        std::thread t1([p1 = std::move(p1)]() mutable {\n            p1.set_value(read_value(\"v1.txt\"));\n        });\n        t1.detach(); // evil\n\n        std::packaged_task<int()> pt2(read_value, \"v2.txt\");\n        std::future<int> f2 = pt2.get_future();\n        std::thread(std::move(pt2)).detach();\n\n        std::cout << f1.get() + f2.get() << '\\n';\n    }\n\n##### Example (good)\n\nThis example shows one way you could follow the general pattern set by\n`std::async`, in a context where `std::async` itself was unacceptable for\nuse in production.\n\n    void async_example(WorkQueue& wq)\n    {\n        std::future<int> f1 = wq.enqueue([]() {\n            return read_value(\"v1.txt\");\n        });\n        std::future<int> f2 = wq.enqueue([]() {\n            return read_value(\"v2.txt\");\n        });\n        std::cout << f1.get() + f2.get() << '\\n';\n    }\n\nAny threads spawned to execute the code of `read_value` are hidden behind\nthe call to `WorkQueue::enqueue`. The user code deals only with `future`\nobjects, never with raw `thread`, `promise`, or `packaged_task` objects.\n\n##### Enforcement\n\n???\n\n\n## <a name=\"sscp-vec\"></a>CP.vec: Vectorization\n\nVectorization is a technique for executing a number of tasks concurrently without introducing explicit synchronization.\nAn operation is simply applied to elements of a data structure (a vector, an array, etc.) in parallel.\nVectorization has the interesting property of often requiring no non-local changes to a program.\nHowever, vectorization works best with simple data structures and with algorithms specifically crafted to enable it.\n\nVectorization rule summary:\n\n* ???\n* ???\n\n## <a name=\"sscp-free\"></a>CP.free: Lock-free programming\n\nSynchronization using `mutex`es and `condition_variable`s can be relatively expensive.\nFurthermore, it can lead to deadlock.\nFor performance and to eliminate the possibility of deadlock, we sometimes have to use the tricky low-level \"lock-free\" facilities\nthat rely on briefly gaining exclusive (\"atomic\") access to memory.\nLock-free programming is also used to implement higher-level concurrency mechanisms, such as `thread`s and `mutex`es.\n\nLock-free programming rule summary:\n\n* [CP.100: Don't use lock-free programming unless you absolutely have to](#rconc-lockfree)\n* [CP.101: Distrust your hardware/compiler combination](#rconc-distrust)\n* [CP.102: Carefully study the literature](#rconc-literature)\n* how/when to use atomics\n* avoid starvation\n* use a lock-free data structure rather than hand-crafting specific lock-free access\n* [CP.110: Do not write your own double-checked locking for initialization](#rconc-double)\n* [CP.111: Use a conventional pattern if you really need double-checked locking](#rconc-double-pattern)\n* how/when to compare and swap\n\n\n### <a name=\"rconc-lockfree\"></a>CP.100: Don't use lock-free programming unless you absolutely have to\n\n##### Reason\n\nIt's error-prone and requires expert level knowledge of language features, machine architecture, and data structures.\n\n##### Example, bad\n\n    extern atomic<Link*> head;        // the shared head of a linked list\n\n    Link* nh = new Link(data, nullptr);    // make a link ready for insertion\n    Link* h = head.load();                 // read the shared head of the list\n\n    do {\n        if (h->data <= data) break;        // if so, insert elsewhere\n        nh->next = h;                      // next element is the previous head\n    } while (!head.compare_exchange_weak(h, nh));    // write nh to head or to h\n\nSpot the bug.\nIt would be really hard to find through testing.\nRead up on the ABA problem.\n\n##### Exception\n\n[Atomic variables](#???) can be used simply and safely, as long as you are using the sequentially consistent memory model (memory_order_seq_cst), which is the default.\n\n##### Note\n\nHigher-level concurrency mechanisms, such as `thread`s and `mutex`es are implemented using lock-free programming.\n\n**Alternative**: Use lock-free data structures implemented by others as part of some library.\n\n\n### <a name=\"rconc-distrust\"></a>CP.101: Distrust your hardware/compiler combination\n\n##### Reason\n\nThe low-level hardware interfaces used by lock-free programming are among the hardest to implement well and among\nthe areas where the most subtle portability problems occur.\nIf you are doing lock-free programming for performance, you need to check for regressions.\n\n##### Note\n\nInstruction reordering (static and dynamic) makes it hard for us to think effectively at this level (especially if you use relaxed memory models).\nExperience, (semi)formal models and model checking can be useful.\nTesting - often to an extreme extent - is essential.\n\"Don't fly too close to the sun.\"\n\n##### Enforcement\n\nHave strong rules for re-testing in place that covers any change in hardware, operating system, compiler, and libraries.\n\n\n### <a name=\"rconc-literature\"></a>CP.102: Carefully study the literature\n\n##### Reason\n\nWith the exception of atomics and a few other standard patterns, lock-free programming is really an expert-only topic.\nBecome an expert before shipping lock-free code for others to use.\n\n##### References\n\n* Anthony Williams: C++ concurrency in action. Manning Publications.\n* Boehm, Adve, You Don't Know Jack About Shared Variables or Memory Models, Communications of the ACM, Feb 2012.\n* Boehm, \"Threads Basics\", HPL TR 2009-259.\n* Adve, Boehm, \"Memory Models: A Case for Rethinking Parallel Languages and Hardware\", Communications of the ACM, August 2010.\n* Boehm, Adve, \"Foundations of the C++ Concurrency Memory Model\", PLDI 08.\n* Mark Batty, Scott Owens, Susmit Sarkar, Peter Sewell, and Tjark Weber, \"Mathematizing C++ Concurrency\", POPL 2011.\n* Damian Dechev, Peter Pirkelbauer, and Bjarne Stroustrup: Understanding and Effectively Preventing the ABA Problem in Descriptor-based Lock-free Designs. 13th IEEE Computer Society ISORC 2010 Symposium. May 2010.\n* Damian Dechev and Bjarne Stroustrup: Scalable Non-blocking Concurrent Objects for Mission Critical Code. ACM OOPSLA'09. October 2009\n* Damian Dechev, Peter Pirkelbauer, Nicolas Rouquette, and Bjarne Stroustrup: Semantically Enhanced Containers for Concurrent Real-Time Systems. Proc. 16th Annual IEEE International Conference and Workshop on the Engineering of Computer Based Systems (IEEE ECBS). April 2009.\n* Maurice Herlihy, Nir Shavit, Victor Luchangco, Michael Spear, \"The Art of Multiprocessor Programming\", 2nd ed. September 2020\n\n### <a name=\"rconc-double\"></a>CP.110: Do not write your own double-checked locking for initialization\n\n##### Reason\n\nSince C++11, static local variables are now initialized in a thread-safe way. When combined with the RAII pattern, static local variables can replace the need for writing your own double-checked locking for initialization. std::call_once can also achieve the same purpose. Use either static local variables of C++11 or std::call_once instead of writing your own double-checked locking for initialization.\n\n##### Example\n\nExample with std::call_once.\n\n    void f()\n    {\n        static std::once_flag my_once_flag;\n        std::call_once(my_once_flag, []()\n        {\n            // do this only once\n        });\n        // ...\n    }\n\nExample with thread-safe static local variables of C++11.\n\n    void f()\n    {\n        // Assuming the compiler is compliant with C++11\n        static My_class my_object; // Constructor called only once\n        // ...\n    }\n\n    class My_class\n    {\n    public:\n        My_class()\n        {\n            // do this only once\n        }\n    };\n\n##### Enforcement\n\n??? Is it possible to detect the idiom?\n\n\n### <a name=\"rconc-double-pattern\"></a>CP.111: Use a conventional pattern if you really need double-checked locking\n\n##### Reason\n\nDouble-checked locking is easy to mess up. If you really need to write your own double-checked locking, in spite of the rules [CP.110: Do not write your own double-checked locking for initialization](#rconc-double) and [CP.100: Don't use lock-free programming unless you absolutely have to](#rconc-lockfree), then do it in a conventional pattern.\n\nThe uses of the double-checked locking pattern that are not in violation of [CP.110: Do not write your own double-checked locking for initialization](#rconc-double) arise when a non-thread-safe action is both hard and rare, and there exists a fast thread-safe test that can be used to guarantee that the action is not needed, but cannot be used to guarantee the converse.\n\n##### Example, bad\n\nThe use of volatile does not make the first check thread-safe, see also [CP.200: Use `volatile` only to talk to non-C++ memory](#rconc-volatile2)\n\n    mutex action_mutex;\n    volatile bool action_needed;\n\n    if (action_needed) {\n        std::lock_guard<std::mutex> lock(action_mutex);\n        if (action_needed) {\n            take_action();\n            action_needed = false;\n        }\n    }\n\n##### Example, good\n\n    mutex action_mutex;\n    atomic<bool> action_needed;\n\n    if (action_needed) {\n        std::lock_guard<std::mutex> lock(action_mutex);\n        if (action_needed) {\n            take_action();\n            action_needed = false;\n        }\n    }\n\nFine-tuned memory order might be beneficial where acquire load is more efficient than sequentially-consistent load\n\n    mutex action_mutex;\n    atomic<bool> action_needed;\n\n    if (action_needed.load(memory_order_acquire)) {\n        lock_guard<std::mutex> lock(action_mutex);\n        if (action_needed.load(memory_order_relaxed)) {\n            take_action();\n            action_needed.store(false, memory_order_release);\n        }\n    }\n\n##### Enforcement\n\n??? Is it possible to detect the idiom?\n\n\n## <a name=\"sscp-etc\"></a>CP.etc: Etc. concurrency rules\n\nThese rules defy simple categorization:\n\n* [CP.200: Use `volatile` only to talk to non-C++ memory](#rconc-volatile2)\n* [CP.201: ??? Signals](#rconc-signal)\n\n### <a name=\"rconc-volatile2\"></a>CP.200: Use `volatile` only to talk to non-C++ memory\n\n##### Reason\n\n`volatile` is used to refer to objects that are shared with \"non-C++\" code or hardware that does not follow the C++ memory model.\n\n##### Example\n\n    const volatile long clock;\n\nThis describes a register constantly updated by a clock circuit.\n`clock` is `volatile` because its value will change without any action from the C++ program that uses it.\nFor example, reading `clock` twice will often yield two different values, so the optimizer had better not optimize away the second read in this code:\n\n    long t1 = clock;\n    // ... no use of clock here ...\n    long t2 = clock;\n\n`clock` is `const` because the program should not try to write to `clock`.\n\n##### Note\n\nUnless you are writing the lowest level code manipulating hardware directly, consider `volatile` an esoteric feature that is best avoided.\n\n##### Example\n\nUsually C++ code receives `volatile` memory that is owned elsewhere (hardware or another language):\n\n    int volatile* vi = get_hardware_memory_location();\n        // note: we get a pointer to someone else's memory here\n        // volatile says \"treat this with extra respect\"\n\nSometimes C++ code allocates the `volatile` memory and shares it with \"elsewhere\" (hardware or another language) by deliberately escaping a pointer:\n\n    static volatile long vl;\n    please_use_this(&vl);   // escape a reference to this to \"elsewhere\" (not C++)\n\n##### Example, bad\n\n`volatile` local variables are nearly always wrong -- how can they be shared with other languages or hardware if they're ephemeral?\nThe same applies almost as strongly to data members, for the same reason.\n\n    void f()\n    {\n        volatile int i = 0; // bad, volatile local variable\n        // etc.\n    }\n\n    class My_type {\n        volatile int i = 0; // suspicious, volatile data member\n        // etc.\n    };\n\n##### Note\n\nIn C++, unlike in some other languages, `volatile` has [nothing to do with synchronization](#rconc-volatile).\n\n##### Enforcement\n\n* Flag `volatile T` local and data members; almost certainly you intended to use `atomic<T>` instead.\n* ???\n\n### <a name=\"rconc-signal\"></a>CP.201: ??? Signals\n\n???UNIX signal handling???. Might be worth reminding how little is async-signal-safe, and how to communicate with a signal handler (best is probably \"not at all\")\n\n\n# <a name=\"s-errors\"></a>E: Error handling\n\nError handling involves:\n\n* Detecting an error\n* Transmitting information about an error to some handler code\n* Preserving a valid state of the program\n* Avoiding resource leaks\n\nIt is not possible to recover from all errors. If recovery from an error is not possible, it is important to quickly \"get out\" in a well-defined way. A strategy for error handling must be simple, or it becomes a source of even worse errors.  Untested and rarely executed error-handling code is itself the source of many bugs.\n\nThe rules are designed to help avoid several kinds of errors:\n\n* Type violations (e.g., misuse of `union`s and casts)\n* Resource leaks (including memory leaks)\n* Bounds errors\n* Lifetime errors (e.g., accessing an object after it has been `delete`d)\n* Complexity errors (logical errors made likely by overly complex expression of ideas)\n* Interface errors (e.g., an unexpected value is passed through an interface)\n\nError-handling rule summary:\n\n* [E.1: Develop an error-handling strategy early in a design](#re-design)\n* [E.2: Throw an exception to signal that a function can't perform its assigned task](#re-throw)\n* [E.3: Use exceptions for error handling only](#re-errors)\n* [E.4: Design your error-handling strategy around invariants](#re-design-invariants)\n* [E.5: Let a constructor establish an invariant, and throw if it cannot](#re-invariant)\n* [E.6: Use RAII to prevent leaks](#re-raii)\n* [E.7: State your preconditions](#re-precondition)\n* [E.8: State your postconditions](#re-postcondition)\n\n* [E.12: Use `noexcept` when exiting a function because of a `throw` is impossible or unacceptable](#re-noexcept)\n* [E.13: Never throw while being the direct owner of an object](#re-never-throw)\n* [E.14: Use purpose-designed user-defined types as exceptions (not built-in types)](#re-exception-types)\n* [E.15: Throw by value, catch exceptions from a hierarchy by reference](#re-exception-ref)\n* [E.16: Destructors, deallocation, `swap`, and exception type copy/move construction must never fail](#re-never-fail)\n* [E.17: Don't try to catch every exception in every function](#re-not-always)\n* [E.18: Minimize the use of explicit `try`/`catch`](#re-catch)\n* [E.19: Use a `final_action` object to express cleanup if no suitable resource handle is available](#re-finally)\n\n* [E.25: If you can't throw exceptions, simulate RAII for resource management](#re-no-throw-raii)\n* [E.26: If you can't throw exceptions, consider failing fast](#re-no-throw-crash)\n* [E.27: If you can't throw exceptions, use error codes systematically](#re-no-throw-codes)\n* [E.28: Avoid error handling based on global state (e.g. `errno`)](#re-no-throw)\n\n* [E.30: Don't use exception specifications](#re-specifications)\n* [E.31: Properly order your `catch`-clauses](#re_catch)\n\n### <a name=\"re-design\"></a>E.1: Develop an error-handling strategy early in a design\n\n##### Reason\n\nA consistent and complete strategy for handling errors and resource leaks is hard to retrofit into a system.\n\n### <a name=\"re-throw\"></a>E.2: Throw an exception to signal that a function can't perform its assigned task\n\n##### Reason\n\nTo make error handling systematic, robust, and non-repetitive.\n\n##### Example\n\n    struct Foo {\n        vector<Thing> v;\n        File_handle f;\n        string s;\n    };\n\n    void use()\n    {\n        Foo bar { {Thing{1}, Thing{2}, Thing{monkey} }, {\"my_file\", \"r\"}, \"Here we go!\"};\n        // ...\n    }\n\nHere, `vector` and `string`s constructors might not be able to allocate sufficient memory for their elements, `vector`s constructor might not be able to copy the `Thing`s in its initializer list, and `File_handle` might not be able to open the required file.\nIn each case, they throw an exception for `use()`'s caller to handle.\nIf `use()` could handle the failure to construct `bar` it can take control using `try`/`catch`.\nIn either case, `Foo`'s constructor correctly destroys constructed members before passing control to whatever tried to create a `Foo`.\nNote that there is no return value that could contain an error code.\n\nThe `File_handle` constructor might be defined like this:\n\n    File_handle::File_handle(const string& name, const string& mode)\n        : f{fopen(name.c_str(), mode.c_str())}\n    {\n        if (!f)\n            throw runtime_error{\"File_handle: could not open \" + name + \" as \" + mode};\n    }\n\n##### Note\n\nIt is often said that exceptions are meant to signal exceptional events and failures.\nHowever, that's a bit circular because \"what is exceptional?\"\nExamples:\n\n* A precondition that cannot be met\n* A constructor that cannot construct an object (failure to establish its class's [invariant](#rc-struct))\n* An out-of-range error (e.g., `v[v.size()] = 7`)\n* Inability to acquire a resource (e.g., the network is down)\n\nIn contrast, termination of an ordinary loop is not exceptional.\nUnless the loop was meant to be infinite, termination is normal and expected.\n\n##### Note\n\nDon't use a `throw` as simply an alternative way of returning a value from a function.\n\n##### Exception\n\nSome systems, such as hard-real-time systems require a guarantee that an action is taken in a (typically short) constant maximum time known before execution starts. Such systems can use exceptions only if there is tool support for accurately predicting the maximum time to recover from a `throw`.\n\n**See also**: [RAII](#re-raii)\n\n**See also**: [discussion](#sd-noexcept)\n\n##### Note\n\nBefore deciding that you cannot afford or don't like exception-based error handling, have a look at the [alternatives](#re-no-throw-raii);\nthey have their own complexities and problems.\nAlso, as far as possible, measure before making claims about efficiency.\n\n### <a name=\"re-errors\"></a>E.3: Use exceptions for error handling only\n\n##### Reason\n\nTo keep error handling separated from \"ordinary code.\"\nC++ implementations tend to be optimized based on the assumption that exceptions are rare.\n\n##### Example, don't\n\n    // don't: exception not used for error handling\n    int find_index(vector<string>& vec, const string& x)\n    {\n        try {\n            for (gsl::index i = 0; i < vec.size(); ++i)\n                if (vec[i] == x) throw i;  // found x\n        }\n        catch (int i) {\n            return i;\n        }\n        return -1;   // not found\n    }\n\nThis is more complicated and most likely runs much slower than the obvious alternative.\nThere is nothing exceptional about finding a value in a `vector`.\n\n##### Enforcement\n\nWould need to be heuristic.\nLook for exception values \"leaked\" out of `catch` clauses.\n\n### <a name=\"re-design-invariants\"></a>E.4: Design your error-handling strategy around invariants\n\n##### Reason\n\nTo use an object it must be in a valid state (defined formally or informally by an invariant) and to recover from an error every object not destroyed must be in a valid state.\n\n##### Note\n\nAn [invariant](#rc-struct) is a logical condition for the members of an object that a constructor must establish for the public member functions to assume.\n\n##### Enforcement\n\n???\n\n### <a name=\"re-invariant\"></a>E.5: Let a constructor establish an invariant, and throw if it cannot\n\n##### Reason\n\nLeaving an object without its invariant established is asking for trouble.\nNot all member functions can be called.\n\n##### Example\n\n    class Vector {  // very simplified vector of doubles\n        // if elem != nullptr then elem points to sz doubles\n    public:\n        Vector() : elem{nullptr}, sz{0}{}\n        Vector(int s) : elem{new double[s]}, sz{s} { /* initialize elements */ }\n        ~Vector() { delete [] elem; }\n        double& operator[](int s) { return elem[s]; }\n        // ...\n    private:\n        owner<double*> elem;\n        int sz;\n    };\n\nThe class invariant - here stated as a comment - is established by the constructors.\n`new` throws if it cannot allocate the required memory.\nThe operators, notably the subscript operator, rely on the invariant.\n\n**See also**: [If a constructor cannot construct a valid object, throw an exception](#rc-throw)\n\n##### Enforcement\n\nFlag classes with `private` state without a constructor (public, protected, or private).\n\n### <a name=\"re-raii\"></a>E.6: Use RAII to prevent leaks\n\n##### Reason\n\nLeaks are typically unacceptable.\nManual resource release is error-prone.\nRAII (\"Resource Acquisition Is Initialization\") is the simplest, most systematic way of preventing leaks.\n\n##### Example\n\n    void f1(int i)   // Bad: possible leak\n    {\n        int* p = new int[12];\n        // ...\n        if (i < 17) throw Bad{\"in f()\", i};\n        // ...\n    }\n\nWe could carefully release the resource before the throw:\n\n    void f2(int i)   // Clumsy and error-prone: explicit release\n    {\n        int* p = new int[12];\n        // ...\n        if (i < 17) {\n            delete[] p;\n            throw Bad{\"in f()\", i};\n        }\n        // ...\n    }\n\nThis is verbose. In larger code with multiple possible `throw`s explicit releases become repetitive and error-prone.\n\n    void f3(int i)   // OK: resource management done by a handle (but see below)\n    {\n        auto p = make_unique<int[]>(12);\n        // ...\n        if (i < 17) throw Bad{\"in f()\", i};\n        // ...\n    }\n\nNote that this works even when the `throw` is implicit because it happened in a called function:\n\n    void f4(int i)   // OK: resource management done by a handle (but see below)\n    {\n        auto p = make_unique<int[]>(12);\n        // ...\n        helper(i);   // might throw\n        // ...\n    }\n\nUnless you really need pointer semantics, use a local resource object:\n\n    void f5(int i)   // OK: resource management done by local object\n    {\n        vector<int> v(12);\n        // ...\n        helper(i);   // might throw\n        // ...\n    }\n\nThat's even simpler and safer, and often more efficient.\n\n##### Note\n\nIf there is no obvious resource handle and for some reason defining a proper RAII object/handle is infeasible,\nas a last resort, cleanup actions can be represented by a [`final_action`](#re-finally) object.\n\n##### Note\n\nBut what do we do if we are writing a program where exceptions cannot be used?\nFirst challenge that assumption; there are many anti-exceptions myths around.\nWe know of only a few good reasons:\n\n* We are on a system so small that the exception support would eat up most of our 2K memory.\n* We are in a hard-real-time system and we don't have tools that guarantee us that an exception is handled within the required time.\n* We are in a system with tons of legacy code using lots of pointers in difficult-to-understand ways\n  (in particular without a recognizable ownership strategy) so that exceptions could cause leaks.\n* Our implementation of the C++ exception mechanisms is unreasonably poor\n(slow, memory consuming, failing to work correctly for dynamically linked libraries, etc.).\nComplain to your implementation purveyor; if no user complains, no improvement will happen.\n* We get fired if we challenge our manager's ancient wisdom.\n\nOnly the first of these reasons is fundamental, so whenever possible, use exceptions to implement RAII, or design your RAII objects to never fail.\nWhen exceptions cannot be used, simulate RAII.\nThat is, systematically check that objects are valid after construction and still release all resources in the destructor.\nOne strategy is to add a `valid()` operation to every resource handle:\n\n    void f()\n    {\n        vector<string> vs(100);   // not std::vector: valid() added\n        if (!vs.valid()) {\n            // handle error or exit\n        }\n\n        ifstream fs(\"foo\");   // not std::ifstream: valid() added\n        if (!fs.valid()) {\n            // handle error or exit\n        }\n\n        // ...\n    } // destructors clean up as usual\n\nObviously, this increases the size of the code, doesn't allow for implicit propagation of \"exceptions\" (`valid()` checks), and `valid()` checks can be forgotten.\nPrefer to use exceptions.\n\n**See also**: [Use of `noexcept`](#re-noexcept)\n\n##### Enforcement\n\n???\n\n### <a name=\"re-precondition\"></a>E.7: State your preconditions\n\n##### Reason\n\nTo avoid interface errors.\n\n**See also**: [precondition rule](#ri-pre)\n\n### <a name=\"re-postcondition\"></a>E.8: State your postconditions\n\n##### Reason\n\nTo avoid interface errors.\n\n**See also**: [postcondition rule](#ri-post)\n\n### <a name=\"re-noexcept\"></a>E.12: Use `noexcept` when exiting a function because of a `throw` is impossible or unacceptable\n\n##### Reason\n\nTo make error handling systematic, robust, and efficient.\n\n##### Example\n\n    double compute(double d) noexcept\n    {\n        return log(sqrt(d <= 0 ? 1 : d));\n    }\n\nHere, we know that `compute` will not throw because it is composed out of operations that don't throw.\nBy declaring `compute` to be `noexcept`, we give the compiler and human readers information that can make it easier for them to understand and manipulate `compute`.\n\n##### Note\n\nMany standard-library functions are `noexcept` including all the standard-library functions \"inherited\" from the C Standard Library.\n\n##### Example\n\n    vector<double> munge(const vector<double>& v) noexcept\n    {\n        vector<double> v2(v.size());\n        // ... do something ...\n    }\n\nThe `noexcept` here states that I am not willing or able to handle the situation where I cannot construct the local `vector`.\nThat is, I consider memory exhaustion a serious design error (on par with hardware failures) so that I'm willing to crash the program if it happens.\n\n##### Note\n\nDo not use traditional [exception-specifications](#re-specifications).\n\n##### See also\n\n[discussion](#sd-noexcept).\n\n### <a name=\"re-never-throw\"></a>E.13: Never throw while being the direct owner of an object\n\n##### Reason\n\nThat would be a leak.\n\n##### Example\n\n    void leak(int x)   // don't: might leak\n    {\n        auto p = new int{7};\n        if (x < 0) throw Get_me_out_of_here{};  // might leak *p\n        // ...\n        delete p;   // we might never get here\n    }\n\nOne way of avoiding such problems is to use resource handles consistently:\n\n    void no_leak(int x)\n    {\n        auto p = make_unique<int>(7);\n        if (x < 0) throw Get_me_out_of_here{};  // will delete *p if necessary\n        // ...\n        // no need for delete p\n    }\n\nAnother solution (often better) would be to use a local variable to eliminate explicit use of pointers:\n\n    void no_leak_simplified(int x)\n    {\n        vector<int> v(7);\n        // ...\n    }\n\n##### Note\n\nIf you have a local \"thing\" that requires cleanup, but is not represented by an object with a destructor, such cleanup must\nalso be done before a `throw`.\nSometimes, [`finally()`](#re-finally) can make such unsystematic cleanup a bit more manageable.\n\n### <a name=\"re-exception-types\"></a>E.14: Use purpose-designed user-defined types as exceptions (not built-in types)\n\n##### Reason\n\nA user-defined type can better transmit information about an error to a handler.  Information\ncan be encoded into the type itself and the type is unlikely to clash with other people's exceptions.\n\n##### Example\n\n    throw 7; // bad\n\n    throw \"something bad\";  // bad\n\n    throw std::exception{}; // bad - no info\n\nDeriving from `std::exception` gives the flexibility to catch the specific exception or handle generally through `std::exception`:\n\n    class MyException : public std::runtime_error\n    {\n    public:\n        MyException(const string& msg) : std::runtime_error{msg} {}\n        // ...\n    };\n\n    // ...\n\n    throw MyException{\"something bad\"};  // good\n\nExceptions do not need to be derived from `std::exception`:\n\n    class MyCustomError final {};  // not derived from std::exception\n\n    // ...\n\n    throw MyCustomError{};  // good - handlers must catch this type (or ...)\n\nLibrary types derived from `std::exception` can be used as generic exceptions if\nno useful information can be added at the point of detection:\n\n    throw std::runtime_error(\"something bad\"); // good\n\n    // ...\n\n    throw std::invalid_argument(\"i is not even\"); // good\n\n`enum` classes are also allowed:\n\n    enum class alert {RED, YELLOW, GREEN};\n\n    throw alert::RED; // good\n\n##### Enforcement\n\nCatch `throw` of built-in types and `std::exception`.\n\n### <a name=\"re-exception-ref\"></a>E.15: Throw by value, catch exceptions from a hierarchy by reference\n\n##### Reason\n\nThrowing by value (not by pointer) and catching by reference prevents copying, especially slicing base subobjects.\n\n##### Example; bad\n\n    void f()\n    {\n        try {\n            // ...\n            throw new widget{}; // don't: throw by value, not by raw pointer\n            // ...\n        }\n        catch (base_class e) {  // don't: might slice\n            // ...\n        }\n    }\n\nInstead, use a reference:\n\n    catch (base_class& e) { /* ... */ }\n\nor - typically better still - a `const` reference:\n\n    catch (const base_class& e) { /* ... */ }\n\nMost handlers do not modify their exception and in general we [recommend use of `const`](#res-const).\n\n##### Note\n\nCatch by value can be appropriate for a small value type such as an `enum` value.\n\n##### Note\n\nTo rethrow a caught exception use `throw;` not `throw e;`. Using `throw e;` would throw a new copy of `e` (sliced to the static type `std::exception`, when the exception is caught by `catch (const std::exception& e)`) instead of rethrowing the original exception of type `std::runtime_error`. (But keep [Don't try to catch every exception in every function](#re-not-always) and [Minimize the use of explicit `try`/`catch`](#re-catch) in mind.)\n\n##### Enforcement\n\n* Flag catching by value of a type that has a virtual function.\n* Flag throwing raw pointers.\n\n### <a name=\"re-never-fail\"></a>E.16: Destructors, deallocation, `swap`, and exception type copy/move construction must never fail\n\n##### Reason\n\nWe don't know how to write reliable programs if a destructor, a swap, a memory deallocation, or attempting to copy/move-construct an exception object fails; that is, if it exits by an exception or simply doesn't perform its required action.\n\n##### Example, don't\n\n    class Connection {\n        // ...\n    public:\n        ~Connection()   // Don't: very bad destructor\n        {\n            if (cannot_disconnect()) throw I_give_up{information};\n            // ...\n        }\n    };\n\n##### Note\n\nMany have tried to write reliable code violating this rule for examples, such as a network connection that \"refuses to close\".\nTo the best of our knowledge nobody has found a general way of doing this.\nOccasionally, for very specific examples, you can get away with setting some state for future cleanup.\nFor example, we might put a socket that does not want to close on a \"bad socket\" list,\nto be examined by a regular sweep of the system state.\nEvery example we have seen of this is error-prone, specialized, and often buggy.\n\n##### Note\n\nThe standard library assumes that destructors, deallocation functions (e.g., `operator delete`), and `swap` do not throw. If they do, basic standard-library invariants are broken.\n\n##### Note\n\n* Deallocation functions, including `operator delete`, must be `noexcept`.\n* `swap` functions must be `noexcept`.\n* Most destructors are implicitly `noexcept` by default.\n* Also, [make move operations `noexcept`](#rc-move-noexcept).\n* If writing a type intended to be used as an exception type, ensure its copy constructor is `noexcept`. In general we cannot mechanically enforce this, because we do not know whether a type is intended to be used as an exception type.\n* Try not to `throw` a type whose copy constructor is not `noexcept`. In general we cannot mechanically enforce this, because even `throw std::string(...)` could throw but does not in practice.\n\n##### Enforcement\n\n* Catch destructors, deallocation operations, and `swap`s that `throw`.\n* Catch such operations that are not `noexcept`.\n\n**See also**: [discussion](#sd-never-fail)\n\n### <a name=\"re-not-always\"></a>E.17: Don't try to catch every exception in every function\n\n##### Reason\n\nCatching an exception in a function that cannot take a meaningful recovery action leads to complexity and waste.\nLet an exception propagate until it reaches a function that can handle it.\nLet cleanup actions on the unwinding path be handled by [RAII](#re-raii).\n\n##### Example, don't\n\n    void f()   // bad\n    {\n        try {\n            // ...\n        }\n        catch (...) {\n            // no action\n            throw;   // propagate exception\n        }\n    }\n\n##### Enforcement\n\n* Flag nested try-blocks.\n* Flag source code files with a too high ratio of try-blocks to functions. (??? Problem: define \"too high\")\n\n### <a name=\"re-catch\"></a>E.18: Minimize the use of explicit `try`/`catch`\n\n##### Reason\n\n `try`/`catch` is verbose and non-trivial uses are error-prone.\n `try`/`catch` can be a sign of unsystematic and/or low-level resource management or error handling.\n\n##### Example, Bad\n\n    void f(zstring s)\n    {\n        Gadget* p;\n        try {\n            p = new Gadget(s);\n            // ...\n            delete p;\n        }\n        catch (Gadget_construction_failure) {\n            delete p;\n            throw;\n        }\n    }\n\nThis code is messy.\nThere could be a leak from the naked pointer in the `try` block.\nNot all exceptions are handled.\n`deleting` an object that failed to construct is almost certainly a mistake.\nBetter:\n\n    void f2(zstring s)\n    {\n        Gadget g {s};\n    }\n\n##### Alternatives\n\n* proper resource handles and [RAII](#re-raii)\n* [`finally`](#re-finally)\n\n##### Enforcement\n\n??? hard, needs a heuristic\n\n### <a name=\"re-finally\"></a>E.19: Use a `final_action` object to express cleanup if no suitable resource handle is available\n\n##### Reason\n\n`finally` from the [GSL](#gsl-guidelines-support-library) is less verbose and harder to get wrong than `try`/`catch`.\n\n##### Example\n\n    void f(int n)\n    {\n        void* p = malloc(n);\n        auto _ = gsl::finally([p] { free(p); });\n        // ...\n    }\n\n##### Note\n\n`finally` is not as messy as `try`/`catch`, but it is still ad-hoc.\nPrefer [proper resource management objects](#re-raii).\nConsider `finally` a last resort.\n\n##### Note\n\nUse of `finally` is a systematic and reasonably clean alternative to the old [`goto exit;` technique](#re-no-throw-codes)\nfor dealing with cleanup where resource management is not systematic.\n\n##### Enforcement\n\nHeuristic: Detect `goto exit;`\n\n### <a name=\"re-no-throw-raii\"></a>E.25: If you can't throw exceptions, simulate RAII for resource management\n\n##### Reason\n\nEven without exceptions, [RAII](#re-raii) is usually the best and most systematic way of dealing with resources.\n\n##### Note\n\nError handling using exceptions is the only complete and systematic way of handling non-local errors in C++.\nIn particular, non-intrusively signaling failure to construct an object requires an exception.\nSignaling errors in a way that cannot be ignored requires exceptions.\nIf you can't use exceptions, simulate their use as best you can.\n\nA lot of fear of exceptions is misguided.\nWhen used for exceptional circumstances in code that is not littered with pointers and complicated control structures,\nexception handling is almost always affordable (in time and space) and almost always leads to better code.\nThis, of course, assumes a good implementation of the exception handling mechanisms, which is not available on all systems.\nThere are also cases where the problems above do not apply, but exceptions cannot be used for other reasons.\nSome hard-real-time systems are an example: An operation has to be completed within a fixed time with an error or a correct answer.\nIn the absence of appropriate time estimation tools, this is hard to guarantee for exceptions.\nSuch systems (e.g. flight control software) typically also ban the use of dynamic (heap) memory.\n\nSo, the primary guideline for error handling is \"use exceptions and [RAII](#re-raii).\"\nThis section deals with the cases where you either do not have an efficient implementation of exceptions,\nor have such a rat's nest of old-style code\n(e.g., lots of pointers, ill-defined ownership, and lots of unsystematic error handling based on tests of error codes)\nthat it is infeasible to introduce simple and systematic exception handling.\n\nBefore condemning exceptions or complaining too much about their cost, consider examples of the use of [error codes](#re-no-throw-codes).\nConsider the cost and complexity of the use of error codes.\nIf performance is your worry, measure.\n\n##### Example\n\nAssume you wanted to write\n\n    void func(zstring arg)\n    {\n        Gadget g {arg};\n        // ...\n    }\n\nIf the `gadget` isn't correctly constructed, `func` exits with an exception.\nIf we cannot throw an exception, we can simulate this RAII style of resource handling by adding a `valid()` member function to `Gadget`:\n\n    error_indicator func(zstring arg)\n    {\n        Gadget g {arg};\n        if (!g.valid()) return gadget_construction_error;\n        // ...\n        return 0;   // zero indicates \"good\"\n    }\n\nThe problem is of course that the caller now has to remember to test the return value. To encourage doing so, consider adding a `[[nodiscard]]`.\n\n**See also**: [Discussion](#sd-???)\n\n##### Enforcement\n\nPossible (only) for specific versions of this idea: e.g., test for systematic test of `valid()` after resource handle construction\n\n### <a name=\"re-no-throw-crash\"></a>E.26: If you can't throw exceptions, consider failing fast\n\n##### Reason\n\nIf you can't do a good job at recovering, at least you can get out before too much consequential damage is done.\n\n**See also**: [Simulating RAII](#re-no-throw-raii)\n\n##### Note\n\nIf you cannot be systematic about error handling, consider \"crashing\" as a response to any error that cannot be handled locally.\nThat is, if you cannot recover from an error in the context of the function that detected it, call `abort()`, `quick_exit()`,\nor a similar function that will trigger some sort of system restart.\n\nIn systems where you have lots of processes and/or lots of computers, you need to expect and handle fatal crashes anyway,\nsay from hardware failures.\nIn such cases, \"crashing\" is simply leaving error handling to the next level of the system.\n\n##### Example\n\n    void f(int n)\n    {\n        // ...\n        p = static_cast<X*>(malloc(n * sizeof(X)));\n        if (!p) abort();     // abort if memory is exhausted\n        // ...\n    }\n\nMost programs cannot handle memory exhaustion gracefully anyway. This is roughly equivalent to\n\n    void f(int n)\n    {\n        // ...\n        p = new X[n];    // throw if memory is exhausted (by default, terminate)\n        // ...\n    }\n\nTypically, it is a good idea to log the reason for the \"crash\" before exiting.\n\n##### Enforcement\n\nAwkward\n\n### <a name=\"re-no-throw-codes\"></a>E.27: If you can't throw exceptions, use error codes systematically\n\n##### Reason\n\nSystematic use of any error-handling strategy minimizes the chance of forgetting to handle an error.\n\n**See also**: [Simulating RAII](#re-no-throw-raii)\n\n##### Note\n\nThere are several issues to be addressed:\n\n* How do you transmit an error indicator from out of a function?\n* How do you release all resources from a function before doing an error exit?\n* What do you use as an error indicator?\n\nIn general, returning an error indicator implies returning two values: The result and an error indicator.\nThe error indicator can be part of the object, e.g. an object can have a `valid()` indicator\nor a pair of values can be returned.\n\n##### Example\n\n    Gadget make_gadget(int n)\n    {\n        // ...\n    }\n\n    void user()\n    {\n        Gadget g = make_gadget(17);\n        if (!g.valid()) {\n                // error handling\n        }\n        // ...\n    }\n\nThis approach fits with [simulated RAII resource management](#re-no-throw-raii).\nThe `valid()` function could return an `error_indicator` (e.g. a member of an `error_indicator` enumeration).\n\n##### Example\n\nWhat if we cannot or do not want to modify the `Gadget` type?\nIn that case, we must return a pair of values.\nFor example:\n\n    std::pair<Gadget, error_indicator> make_gadget(int n)\n    {\n        // ...\n    }\n\n    void user()\n    {\n        auto r = make_gadget(17);\n        if (!r.second) {\n                // error handling\n        }\n        Gadget& g = r.first;\n        // ...\n    }\n\nAs shown, `std::pair` is a possible return type.\nSome people prefer a specific type.\nFor example:\n\n    Gval make_gadget(int n)\n    {\n        // ...\n    }\n\n    void user()\n    {\n        auto r = make_gadget(17);\n        if (!r.err) {\n                // error handling\n        }\n        Gadget& g = r.val;\n        // ...\n    }\n\nOne reason to prefer a specific return type is to have names for its members, rather than the somewhat cryptic `first` and `second`\nand to avoid confusion with other uses of `std::pair`.\n\n##### Example\n\nIn general, you must clean up before an error exit.\nThis can be messy:\n\n    std::pair<int, error_indicator> user()\n    {\n        Gadget g1 = make_gadget(17);\n        if (!g1.valid()) {\n            return {0, g1_error};\n        }\n\n        Gadget g2 = make_gadget(31);\n        if (!g2.valid()) {\n            cleanup(g1);\n            return {0, g2_error};\n        }\n\n        // ...\n\n        if (all_foobar(g1, g2)) {\n            cleanup(g2);\n            cleanup(g1);\n            return {0, foobar_error};\n        }\n\n        // ...\n\n        cleanup(g2);\n        cleanup(g1);\n        return {res, 0};\n    }\n\nSimulating RAII can be non-trivial, especially in functions with multiple resources and multiple possible errors.\nA not uncommon technique is to gather cleanup at the end of the function to avoid repetition (note that the extra scope around `g2` is undesirable but necessary to make the `goto` version compile):\n\n    std::pair<int, error_indicator> user()\n    {\n        error_indicator err = 0;\n        int res = 0;\n\n        Gadget g1 = make_gadget(17);\n        if (!g1.valid()) {\n            err = g1_error;\n            goto g1_exit;\n        }\n\n        {\n            Gadget g2 = make_gadget(31);\n            if (!g2.valid()) {\n                err = g2_error;\n                goto g2_exit;\n            }\n\n            if (all_foobar(g1, g2)) {\n                err = foobar_error;\n                goto g2_exit;\n            }\n\n            // ...\n\n        g2_exit:\n            if (g2.valid()) cleanup(g2);\n        }\n\n    g1_exit:\n        if (g1.valid()) cleanup(g1);\n        return {res, err};\n    }\n\nThe larger the function, the more tempting this technique becomes.\n`finally` can [ease the pain a bit](#re-finally).\nAlso, the larger the program becomes the harder it is to apply an error-indicator-based error-handling strategy systematically.\n\nWe [prefer exception-based error handling](#re-throw) and recommend [keeping functions short](#rf-single).\n\n**See also**: [Discussion](#sd-???)\n\n**See also**: [Returning multiple values](#rf-out-multi)\n\n##### Enforcement\n\nAwkward.\n\n### <a name=\"re-no-throw\"></a>E.28: Avoid error handling based on global state (e.g. `errno`)\n\n##### Reason\n\nGlobal state is hard to manage and it is easy to forget to check it.\nWhen did you last test the return value of `printf()`?\n\n**See also**: [Simulating RAII](#re-no-throw-raii)\n\n##### Example, bad\n\n    int last_err;\n\n    void f(int n)\n    {\n        // ...\n        p = static_cast<X*>(malloc(n * sizeof(X)));\n        if (!p) last_err = -1;     // error if memory is exhausted\n        // ...\n    }\n\n##### Note\n\nC-style error handling is based on the global variable `errno`, so it is essentially impossible to avoid this style completely.\n\n##### Enforcement\n\nAwkward.\n\n\n### <a name=\"re-specifications\"></a>E.30: Don't use exception specifications\n\n##### Reason\n\nException specifications make error handling brittle, impose a run-time cost, and have been removed from the C++ standard.\n\n##### Example\n\n    int use(int arg)\n        throw(X, Y)\n    {\n        // ...\n        auto x = f(arg);\n        // ...\n    }\n\nIf `f()` throws an exception different from `X` and `Y` the unexpected handler is invoked, which by default terminates.\nThat's OK, but say that we have checked that this cannot happen and `f` is changed to throw a new exception `Z`,\nwe now have a crash on our hands unless we change `use()` (and re-test everything).\nThe snag is that `f()` might be in a library we do not control and the new exception is not anything that `use()` can do\nanything about or is in any way interested in.\nWe can change `use()` to pass `Z` through, but now `use()`'s callers probably need to be modified.\nThis quickly becomes unmanageable.\nAlternatively, we can add a `try`-`catch` to `use()` to map `Z` into an acceptable exception.\nThis, too, quickly becomes unmanageable.\nNote that changes to the set of exceptions often happen at the lowest level of a system\n(e.g., because of changes to a network library or some middleware), so changes \"bubble up\" through long call chains.\nIn a large code base, this could mean that nobody could update to a new version of a library until the last user was modified.\nIf `use()` is part of a library, it might not be possible to update it because a change could affect unknown clients.\n\nThe policy of letting exceptions propagate until they reach a function that potentially can handle it has proven itself over the years.\n\n##### Note\n\nNo. This would not be any better had exception specifications been statically enforced.\nFor example, see [Stroustrup94](#Stroustrup94).\n\n##### Note\n\nIf no exception can be thrown, use [`noexcept`](#re-noexcept).\n\n##### Enforcement\n\nFlag every exception specification.\n\n### <a name=\"re_catch\"></a>E.31: Properly order your `catch`-clauses\n\n##### Reason\n\n`catch`-clauses are evaluated in the order they appear and one clause can hide another.\n\n##### Example, bad\n\n    void f()\n    {\n        // ...\n        try {\n                // ...\n        }\n        catch (Base& b) { /* ... */ }\n        catch (Derived& d) { /* ... */ }\n        catch (...) { /* ... */ }\n        catch (std::exception& e) { /* ... */ }\n    }\n\nIf `Derived`is derived from `Base` the `Derived`-handler will never be invoked.\nThe \"catch everything\" handler ensured that the `std::exception`-handler will never be invoked.\n\n##### Enforcement\n\nFlag all \"hiding handlers\".\n\n# <a name=\"s-const\"></a>Con: Constants and immutability\n\nYou can't have a race condition on a constant.\nIt is easier to reason about a program when many of the objects cannot change their values.\nInterfaces that promise \"no change\" of objects passed as arguments greatly increase readability.\n\nConstant rule summary:\n\n* [Con.1: By default, make objects immutable](#rconst-immutable)\n* [Con.2: By default, make member functions `const`](#rconst-fct)\n* [Con.3: By default, pass pointers and references to `const`s](#rconst-ref)\n* [Con.4: Use `const` to define objects with values that do not change after construction](#rconst-const)\n* [Con.5: Use `constexpr` for values that can be computed at compile time](#rconst-constexpr)\n\n### <a name=\"rconst-immutable\"></a>Con.1: By default, make objects immutable\n\n##### Reason\n\nImmutable objects are easier to reason about, so make objects non-`const` only when there is a need to change their value.\nPrevents accidental or hard-to-notice change of value.\n\n##### Example\n\n    for (const int i : c) cout << i << '\\n';    // just reading: const\n\n    for (int i : c) cout << i << '\\n';          // BAD: just reading\n\n##### Exceptions\n\nA local variable that is returned by value and is cheaper to move than copy should not be declared `const`\nbecause it can force an unnecessary copy.\n\n    std::vector<int> f(int i)\n    {\n        std::vector<int> v{ i, i, i };  // const not needed\n        return v;\n    }\n\nFunction parameters passed by value are rarely mutated, but also rarely declared `const`.\nTo avoid confusion and lots of false positives, don't enforce this rule for function parameters.\n\n    void g(const int i) { ... }  // pedantic\n\nNote that a function parameter is a local variable so changes to it are local.\n\n##### Enforcement\n\n* Flag non-`const` variables that are not modified (except for parameters to avoid many false positives\nand returned local variables)\n\n### <a name=\"rconst-fct\"></a>Con.2: By default, make member functions `const`\n\n##### Reason\n\nA member function should be marked `const` unless it changes the object's observable state.\nThis gives a more precise statement of design intent, better readability, more errors caught by the compiler, and sometimes more optimization opportunities.\n\n##### Example, bad\n\n    class Point {\n        int x, y;\n    public:\n        int getx() { return x; }    // BAD, should be const as it doesn't modify the object's state\n        // ...\n    };\n\n    void f(const Point& pt)\n    {\n        int x = pt.getx();          // ERROR, doesn't compile because getx was not marked const\n    }\n\n##### Note\n\nIt is not inherently bad to pass a pointer or reference to non-`const`,\nbut that should be done only when the called function is supposed to modify the object.\nA reader of code must assume that a function that takes a \"plain\" `T*` or `T&` will modify the object referred to.\nIf it doesn't now, it might do so later without forcing recompilation.\n\n##### Note\n\nThere are code/libraries that offer functions that declare a `T*` even though\nthose functions do not modify that `T`.\nThis is a problem for people modernizing code.\nYou can\n\n* update the library to be `const`-correct; preferred long-term solution\n* \"cast away `const`\"; [best avoided](#res-casts-const)\n* provide a wrapper function\n\nExample:\n\n    void f(int* p);   // old code: f() does not modify `*p`\n    void f(const int* p) { f(const_cast<int*>(p)); } // wrapper\n\nNote that this wrapper solution is a patch that should be used only when the declaration of `f()` cannot be modified,\ne.g. because it is in a library that you cannot modify.\n\n##### Note\n\nA `const` member function can modify the value of an object that is `mutable` or accessed through a pointer member.\nA common use is to maintain a cache rather than repeatedly do a complicated computation.\nFor example, here is a `Date` that caches (memoizes) its string representation to simplify repeated uses:\n\n    class Date {\n    public:\n        // ...\n        const string& string_ref() const\n        {\n            if (string_val == \"\") compute_string_rep();\n            return string_val;\n        }\n        // ...\n    private:\n        void compute_string_rep() const;    // compute string representation and place it in string_val\n        mutable string string_val;\n        // ...\n    };\n\nAnother way of saying this is that `const`ness is not transitive.\nIt is possible for a `const` member function to change the value of `mutable` members and the value of objects accessed\nthrough non-`const` pointers.\nIt is the job of the class to ensure such mutation is done only when it makes sense according to the semantics (invariants)\nit offers to its users.\n\n**See also**: [Pimpl](#ri-pimpl)\n\n##### Enforcement\n\n* Flag a member function that is not marked `const`, but that does not perform a non-`const` operation on any data member.\n\n### <a name=\"rconst-ref\"></a>Con.3: By default, pass pointers and references to `const`s\n\n##### Reason\n\n To avoid a called function unexpectedly changing the value.\n It's far easier to reason about programs when called functions don't modify state.\n\n##### Example\n\n    void f(char* p);        // does f modify *p? (assume it does)\n    void g(const char* p);  // g does not modify *p\n\n##### Note\n\nIt is not inherently bad to pass a pointer or reference to non-`const`,\nbut that should be done only when the called function is supposed to modify the object.\n\n##### Note\n\n[Do not cast away `const`](#res-casts-const).\n\n##### Enforcement\n\n* Flag a function that does not modify an object passed by pointer or reference to non-`const`\n* Flag a function that (using a cast) modifies an object passed by pointer or reference to `const`\n\n### <a name=\"rconst-const\"></a>Con.4: Use `const` to define objects with values that do not change after construction\n\n##### Reason\n\n Prevent surprises from unexpectedly changed object values.\n\n##### Example\n\n    void f()\n    {\n        int x = 7;\n        const int y = 9;\n\n        for (;;) {\n            // ...\n        }\n        // ...\n    }\n\nAs `x` is not `const`, we must assume that it is modified somewhere in the loop.\n\n##### Enforcement\n\n* Flag unmodified non-`const` variables.\n\n### <a name=\"rconst-constexpr\"></a>Con.5: Use `constexpr` for values that can be computed at compile time\n\n##### Reason\n\nBetter performance, better compile-time checking, guaranteed compile-time evaluation, no possibility of race conditions.\n\n##### Example\n\n    double x = f(2);            // possible run-time evaluation\n    const double y = f(2);      // possible run-time evaluation\n    constexpr double z = f(2);  // error unless f(2) can be evaluated at compile time\n\n##### Note\n\nSee F.4.\n\n##### Enforcement\n\n* Flag `const` definitions with constant expression initializers.\n\n# <a name=\"s-templates\"></a>T: Templates and generic programming\n\nGeneric programming is programming using types and algorithms parameterized by types, values, and algorithms.\nIn C++, generic programming is supported by the `template` language mechanisms.\n\nArguments to generic functions are characterized by sets of requirements on the argument types and values involved.\nIn C++, these requirements are expressed by compile-time predicates called concepts.\n\nTemplates can also be used for meta-programming; that is, programs that compose code at compile time.\n\nA central notion in generic programming is \"concepts\"; that is, requirements on template arguments presented as compile-time predicates.\n\"Concepts\" were standardized in C++20, although they were first made available, in slightly older syntax, in GCC 6.1.\n\nTemplate use rule summary:\n\n* [T.1: Use templates to raise the level of abstraction of code](#rt-raise)\n* [T.2: Use templates to express algorithms that apply to many argument types](#rt-algo)\n* [T.3: Use templates to express containers and ranges](#rt-cont)\n* [T.4: Use templates to express syntax tree manipulation](#rt-expr)\n* [T.5: Combine generic and OO techniques to amplify their strengths, not their costs](#rt-generic-oo)\n\nConcept use rule summary:\n\n* [T.10: Specify concepts for all template arguments](#rt-concepts)\n* [T.11: Whenever possible use standard concepts](#rt-std-concepts)\n* [T.12: Prefer concept names over `auto` for local variables](#rt-auto)\n* [T.13: Prefer the shorthand notation for simple, single-type argument concepts](#rt-shorthand)\n* ???\n\nConcept definition rule summary:\n\n* [T.20: Avoid \"concepts\" without meaningful semantics](#rt-low)\n* [T.21: Require a complete set of operations for a concept](#rt-complete)\n* [T.22: Specify axioms for concepts](#rt-axiom)\n* [T.23: Differentiate a refined concept from its more general case by adding new use patterns](#rt-refine)\n* [T.24: Use tag classes or traits to differentiate concepts that differ only in semantics](#rt-tag)\n* [T.25: Avoid complementary constraints](#rt-not)\n* [T.26: Prefer to define concepts in terms of use-patterns rather than simple syntax](#rt-use)\n* [T.30: Use concept negation (`!C<T>`) sparingly to express a minor difference](#rt-???)\n* [T.31: Use concept disjunction (`C1<T> || C2<T>`) sparingly to express alternatives](#rt-???)\n* ???\n\nTemplate interface rule summary:\n\n* [T.40: Use function objects to pass operations to algorithms](#rt-fo)\n* [T.41: Require only essential properties in a template's concepts](#rt-essential)\n* [T.42: Use template aliases to simplify notation and hide implementation details](#rt-alias)\n* [T.43: Prefer `using` over `typedef` for defining aliases](#rt-using)\n* [T.44: Use function templates to deduce class template argument types (where feasible)](#rt-deduce)\n* [T.46: Require template arguments to be at least semiregular](#rt-regular)\n* [T.47: Avoid highly visible unconstrained templates with common names](#rt-visible)\n* [T.48: If your compiler does not support concepts, fake them with `enable_if`](#rt-concept-def)\n* [T.49: Where possible, avoid type-erasure](#rt-erasure)\n\nTemplate definition rule summary:\n\n* [T.60: Minimize a template's context dependencies](#rt-depend)\n* [T.61: Do not over-parameterize members (SCARY)](#rt-scary)\n* [T.62: Place non-dependent class template members in a non-templated base class](#rt-nondependent)\n* [T.64: Use specialization to provide alternative implementations of class templates](#rt-specialization)\n* [T.65: Use tag dispatch to provide alternative implementations of functions](#rt-tag-dispatch)\n* [T.67: Use specialization to provide alternative implementations for irregular types](#rt-specialization2)\n* [T.68: Use `{}` rather than `()` within templates to avoid ambiguities](#rt-cast)\n* [T.69: Inside a template, don't make an unqualified non-member function call unless you intend it to be a customization point](#rt-customization)\n\nTemplate and hierarchy rule summary:\n\n* [T.80: Do not naively templatize a class hierarchy](#rt-hier)\n* [T.81: Do not mix hierarchies and arrays](#rt-array) // ??? somewhere in \"hierarchies\"\n* [T.82: Linearize a hierarchy when virtual functions are undesirable](#rt-linear)\n* [T.83: Do not declare a member function template virtual](#rt-virtual)\n* [T.84: Use a non-template core implementation to provide an ABI-stable interface](#rt-abi)\n* [T.??: ????](#rt-???)\n\nVariadic template rule summary:\n\n* [T.100: Use variadic templates when you need a function that takes a variable number of arguments of a variety of types](#rt-variadic)\n* [T.101: ??? How to pass arguments to a variadic template ???](#rt-variadic-pass)\n* [T.102: ??? How to process arguments to a variadic template ???](#rt-variadic-process)\n* [T.103: Don't use variadic templates for homogeneous argument lists](#rt-variadic-not)\n* [T.??: ????](#rt-???)\n\nMetaprogramming rule summary:\n\n* [T.120: Use template metaprogramming only when you really need to](#rt-metameta)\n* [T.121: Use template metaprogramming primarily to emulate concepts](#rt-emulate)\n* [T.122: Use templates (usually template aliases) to compute types at compile time](#rt-tmp)\n* [T.123: Use `constexpr` functions to compute values at compile time](#rt-fct)\n* [T.124: Prefer to use standard-library TMP facilities](#rt-std-tmp)\n* [T.125: If you need to go beyond the standard-library TMP facilities, use an existing library](#rt-lib)\n* [T.??: ????](#rt-???)\n\nOther template rules summary:\n\n* [T.140: If an operation can be reused, give it a name](#rt-name)\n* [T.141: Use an unnamed lambda if you need a simple function object in one place only](#rt-lambda)\n* [T.142: Use template variables to simplify notation](#rt-var)\n* [T.143: Don't write unintentionally non-generic code](#rt-non-generic)\n* [T.144: Don't specialize function templates](#rt-specialize-function)\n* [T.150: Check that a class matches a concept using `static_assert`](#rt-check-class)\n* [T.??: ????](#rt-???)\n\n## <a name=\"ss-gp\"></a>T.gp: Generic programming\n\nGeneric programming is programming using types and algorithms parameterized by types, values, and algorithms.\n\n### <a name=\"rt-raise\"></a>T.1: Use templates to raise the level of abstraction of code\n\n##### Reason\n\nGenerality. Reuse. Efficiency. Encourages consistent definition of user types.\n\n##### Example, bad\n\nConceptually, the following requirements are wrong because what we want of `T` is more than just the very low-level concepts of \"can be incremented\" or \"can be added\":\n\n    template<typename T>\n        requires Incrementable<T>\n    T sum1(vector<T>& v, T s)\n    {\n        for (auto x : v) s += x;\n        return s;\n    }\n\n    template<typename T>\n        requires Simple_number<T>\n    T sum2(vector<T>& v, T s)\n    {\n        for (auto x : v) s = s + x;\n        return s;\n    }\n\nAssuming that `Incrementable` does not support `+` and `Simple_number` does not support `+=`, we have overconstrained implementers of `sum1` and `sum2`.\nAnd, in this case, missed an opportunity for a generalization.\n\n##### Example\n\n    template<typename T>\n        requires Arithmetic<T>\n    T sum(vector<T>& v, T s)\n    {\n        for (auto x : v) s += x;\n        return s;\n    }\n\nAssuming that `Arithmetic` requires both `+` and `+=`, we have constrained the user of `sum` to provide a complete arithmetic type.\nThat is not a minimal requirement, but it gives the implementer of algorithms much needed freedom and ensures that any `Arithmetic` type\ncan be used for a wide variety of algorithms.\n\nFor additional generality and reusability, we could also use a more general `Container` or `Range` concept instead of committing to only one container, `vector`.\n\n##### Note\n\nIf we define a template to require exactly the operations required for a single implementation of a single algorithm\n(e.g., requiring just `+=` rather than also `=` and `+`) and only those, we have overconstrained maintainers.\nWe aim to minimize requirements on template arguments, but the absolutely minimal requirements of an implementation is rarely a meaningful concept.\n\n##### Note\n\nTemplates can be used to express essentially everything (they are Turing complete), but the aim of generic programming (as expressed using templates)\nis to efficiently generalize operations/algorithms over a set of types with similar semantic properties.\n\n##### Enforcement\n\n* Flag algorithms with \"overly simple\" requirements, such as direct use of specific operators without a concept.\n* Do not flag the definition of the \"overly simple\" concepts themselves; they might simply be building blocks for more useful concepts.\n\n### <a name=\"rt-algo\"></a>T.2: Use templates to express algorithms that apply to many argument types\n\n##### Reason\n\nGenerality. Minimizing the amount of source code. Interoperability. Reuse.\n\n##### Example\n\nThat's the foundation of the STL. A single `find` algorithm easily works with any kind of input range:\n\n    template<typename Iter, typename Val>\n        // requires Input_iterator<Iter>\n        //       && Equality_comparable<Value_type<Iter>, Val>\n    Iter find(Iter b, Iter e, Val v)\n    {\n        // ...\n    }\n\n##### Note\n\nDon't use a template unless you have a realistic need for more than one template argument type.\nDon't overabstract.\n\n##### Enforcement\n\n??? tough, probably needs a human\n\n### <a name=\"rt-cont\"></a>T.3: Use templates to express containers and ranges\n\n##### Reason\n\nContainers need an element type, and expressing that as a template argument is general, reusable, and type safe.\nIt also avoids brittle or inefficient workarounds. Convention: That's the way the STL does it.\n\n##### Example\n\n    template<typename T>\n        // requires Regular<T>\n    class Vector {\n        // ...\n        T* elem;   // points to sz Ts\n        int sz;\n    };\n\n    Vector<double> v(10);\n    v[7] = 9.9;\n\n##### Example, bad\n\n    class Container {\n        // ...\n        void* elem;   // points to size elements of some type\n        int sz;\n    };\n\n    Container c(10, sizeof(double));\n    ((double*) c.elem)[7] = 9.9;\n\nThis doesn't directly express the intent of the programmer and hides the structure of the program from the type system and optimizer.\n\nHiding the `void*` behind macros simply obscures the problems and introduces new opportunities for confusion.\n\n**Exceptions**: If you need an ABI-stable interface, you might have to provide a base implementation and express the (type-safe) template in terms of that.\nSee [Stable base](#rt-abi).\n\n##### Enforcement\n\n* Flag uses of `void*`s and casts outside low-level implementation code\n\n### <a name=\"rt-expr\"></a>T.4: Use templates to express syntax tree manipulation\n\n##### Reason\n\n ???\n\n##### Example\n\n    ???\n\n**Exceptions**: ???\n\n### <a name=\"rt-generic-oo\"></a>T.5: Combine generic and OO techniques to amplify their strengths, not their costs\n\n##### Reason\n\nGeneric and OO techniques are complementary.\n\n##### Example\n\nStatic helps dynamic: Use static polymorphism to implement dynamically polymorphic interfaces.\n\n    class Command {\n        // pure virtual functions\n    };\n\n    // implementations\n    template</*...*/>\n    class ConcreteCommand : public Command {\n        // implement virtuals\n    };\n\n##### Example\n\nDynamic helps static: Offer a generic, comfortable, statically bound interface, but internally dispatch dynamically, so you offer a uniform object layout.\nExamples include type erasure as with `std::shared_ptr`'s deleter (but [don't overuse type erasure](#rt-erasure)).\n\n    #include <memory>\n\n    class Object {\n    public:\n        template<typename T>\n        Object(T&& obj)\n            : concept_(std::make_shared<ConcreteCommand<T>>(std::forward<T>(obj))) {}\n\n        int get_id() const { return concept_->get_id(); }\n\n    private:\n        struct Command {\n            virtual ~Command() {}\n            virtual int get_id() const = 0;\n        };\n\n        template<typename T>\n        struct ConcreteCommand final : Command {\n            ConcreteCommand(T&& obj) noexcept : object_(std::forward<T>(obj)) {}\n            int get_id() const final { return object_.get_id(); }\n\n        private:\n            T object_;\n        };\n\n        std::shared_ptr<Command> concept_;\n    };\n\n    class Bar {\n    public:\n        int get_id() const { return 1; }\n    };\n\n    struct Foo {\n    public:\n        int get_id() const { return 2; }\n    };\n\n    Object o(Bar{});\n    Object o2(Foo{});\n\n##### Note\n\nIn a class template, non-virtual functions are only instantiated if they're used -- but virtual functions are instantiated every time.\nThis can bloat code size, and might overconstrain a generic type by instantiating functionality that is never needed.\nAvoid this, even though the standard-library facets made this mistake.\n\n##### See also\n\n* ref ???\n* ref ???\n* ref ???\n\n##### Enforcement\n\nSee the reference to more specific rules.\n\n## <a name=\"ss-concepts\"></a>T.concepts: Concept rules\n\nConcepts is a C++20 facility for specifying requirements for template arguments.\nThey are crucial in the thinking about generic programming and the basis of much work on future C++ libraries\n(standard and other).\n\nThis section assumes concept support\n\nConcept use rule summary:\n\n* [T.10: Specify concepts for all template arguments](#rt-concepts)\n* [T.11: Whenever possible use standard concepts](#rt-std-concepts)\n* [T.12: Prefer concept names over `auto`](#rt-auto)\n* [T.13: Prefer the shorthand notation for simple, single-type argument concepts](#rt-shorthand)\n* ???\n\nConcept definition rule summary:\n\n* [T.20: Avoid \"concepts\" without meaningful semantics](#rt-low)\n* [T.21: Require a complete set of operations for a concept](#rt-complete)\n* [T.22: Specify axioms for concepts](#rt-axiom)\n* [T.23: Differentiate a refined concept from its more general case by adding new use patterns](#rt-refine)\n* [T.24: Use tag classes or traits to differentiate concepts that differ only in semantics](#rt-tag)\n* [T.25: Avoid complimentary constraints](#rt-not)\n* [T.26: Prefer to define concepts in terms of use-patterns rather than simple syntax](#rt-use)\n* ???\n\n## <a name=\"ss-concept-use\"></a>T.con-use: Concept use\n\n### <a name=\"rt-concepts\"></a>T.10: Specify concepts for all template arguments\n\n##### Reason\n\nCorrectness and readability.\nThe assumed meaning (syntax and semantics) of a template argument is fundamental to the interface of a template.\nA concept dramatically improves documentation and error handling for the template.\nSpecifying concepts for template arguments is a powerful design tool.\n\n##### Example\n\n    template<typename Iter, typename Val>\n        requires input_iterator<Iter>\n                 && equality_comparable_with<iter_value_t<Iter>, Val>\n    Iter find(Iter b, Iter e, Val v)\n    {\n        // ...\n    }\n\nor equivalently and more succinctly:\n\n    template<input_iterator Iter, typename Val>\n        requires equality_comparable_with<iter_value_t<Iter>, Val>\n    Iter find(Iter b, Iter e, Val v)\n    {\n        // ...\n    }\n\n##### Note\n\nPlain `typename` (or `auto`) is the least constraining concept.\nIt should be used only rarely when nothing more than \"it's a type\" can be assumed.\nThis is typically only needed when (as part of template metaprogramming code) we manipulate pure expression trees, postponing type checking.\n\n**References**: TC++PL4\n\n##### Enforcement\n\nFlag template type arguments without concepts\n\n### <a name=\"rt-std-concepts\"></a>T.11: Whenever possible use standard concepts\n\n##### Reason\n\n \"Standard\" concepts (as provided by the [GSL](#gsl-guidelines-support-library) and the ISO standard itself)\nsave us the work of thinking up our own concepts, are better thought out than we can manage to do in a hurry, and improve interoperability.\n\n##### Note\n\nUnless you are creating a new generic library, most of the concepts you need will already be defined by the standard library.\n\n##### Example\n\n    template<typename T>\n        // don't define this: sortable is in <iterator>\n    concept Ordered_container = Sequence<T> && Random_access<Iterator<T>> && Ordered<Value_type<T>>;\n\n    void sort(Ordered_container auto& s);\n\nThis `Ordered_container` is quite plausible, but it is very similar to the `sortable` concept in the standard library.\nIs it better? Is it right? Does it accurately reflect the standard's requirements for `sort`?\nIt is better and simpler just to use `sortable`:\n\n    void sort(sortable auto& s);   // better\n\n##### Note\n\nThe set of \"standard\" concepts is evolving as we approach an ISO standard including concepts.\n\n##### Note\n\nDesigning a useful concept is challenging.\n\n##### Enforcement\n\nHard.\n\n* Look for unconstrained arguments, templates that use \"unusual\"/non-standard concepts, templates that use \"homebrew\" concepts without axioms.\n* Develop a concept-discovery tool (e.g., see [an early experiment](https://www.stroustrup.com/sle2010_webversion.pdf)).\n\n### <a name=\"rt-auto\"></a>T.12: Prefer concept names over `auto` for local variables\n\n##### Reason\n\n `auto` is the weakest concept. Concept names convey more meaning than just `auto`.\n\n##### Example\n\n    vector<string> v{ \"abc\", \"xyz\" };\n    auto& x = v.front();        // bad\n    String auto& s = v.front(); // good (String is a GSL concept)\n\n##### Enforcement\n\n* ???\n\n### <a name=\"rt-shorthand\"></a>T.13: Prefer the shorthand notation for simple, single-type argument concepts\n\n##### Reason\n\nReadability. Direct expression of an idea.\n\n##### Example\n\nTo say \"`T` is `sortable`\":\n\n    template<typename T>       // Correct but verbose: \"The parameter is\n        requires sortable<T>   // of type T which is the name of a type\n    void sort(T&);             // that is sortable\"\n\n    template<sortable T>       // Better: \"The parameter is of type T\n    void sort(T&);             // which is Sortable\"\n\n    void sort(sortable auto&); // Best: \"The parameter is Sortable\"\n\nThe shorter versions better match the way we speak. Note that many templates don't need to use the `template` keyword.\n\n##### Enforcement\n\n* Not feasible in the short term when people convert from the `<typename T>` and `<class T`> notation.\n* Later, flag declarations that first introduce a typename and then constrain it with a simple, single-type-argument concept.\n\n## <a name=\"ss-concepts-def\"></a>T.concepts.def: Concept definition rules\n\nDefining good concepts is non-trivial.\nConcepts are meant to represent fundamental concepts in an application domain (hence the name \"concepts\").\nSimilarly throwing together a set of syntactic constraints to be used for the arguments for a single class or algorithm is not what concepts were designed for\nand will not give the full benefits of the mechanism.\n\nObviously, defining concepts is most useful for code that can use an implementation (e.g., C++20 or later)\nbut defining concepts is in itself a useful design technique and helps catch conceptual errors and clean up the concepts (sic!) of an implementation.\n\n### <a name=\"rt-low\"></a>T.20: Avoid \"concepts\" without meaningful semantics\n\n##### Reason\n\nConcepts are meant to express semantic notions, such as \"a number\", \"a range\" of elements, and \"totally ordered.\"\nSimple constraints, such as \"has a `+` operator\" and \"has a `>` operator\" cannot be meaningfully specified in isolation\nand should be used only as building blocks for meaningful concepts, rather than in user code.\n\n##### Example, bad\n\n    template<typename T>\n    // bad; insufficient\n    concept Addable = requires(T a, T b) { a + b; };\n\n    template<Addable N>\n    auto algo(const N& a, const N& b) // use two numbers\n    {\n        // ...\n        return a + b;\n    }\n\n    int x = 7;\n    int y = 9;\n    auto z = algo(x, y);   // z = 16\n\n    string xx = \"7\";\n    string yy = \"9\";\n    auto zz = algo(xx, yy);   // zz = \"79\"\n\nMaybe the concatenation was expected. More likely, it was an accident. Defining minus equivalently would give dramatically different sets of accepted types.\nThis `Addable` violates the mathematical rule that addition is supposed to be commutative: `a+b == b+a`.\n\n##### Note\n\nThe ability to specify meaningful semantics is a defining characteristic of a true concept, as opposed to a syntactic constraint.\n\n##### Example\n\n    template<typename T>\n    // The operators +, -, *, and / for a number are assumed to follow the usual mathematical rules\n    concept Number = requires(T a, T b) { a + b; a - b; a * b; a / b; };\n\n    template<Number N>\n    auto algo(const N& a, const N& b)\n    {\n        // ...\n        return a + b;\n    }\n\n    int x = 7;\n    int y = 9;\n    auto z = algo(x, y);   // z = 16\n\n    string xx = \"7\";\n    string yy = \"9\";\n    auto zz = algo(xx, yy);   // error: string is not a Number\n\n##### Note\n\nConcepts with multiple operations have far lower chance of accidentally matching a type than a single-operation concept.\n\n##### Enforcement\n\n* Flag single-operation `concepts` when used outside the definition of other `concepts`.\n* Flag uses of `enable_if` that appear to simulate single-operation `concepts`.\n\n\n### <a name=\"rt-complete\"></a>T.21: Require a complete set of operations for a concept\n\n##### Reason\n\nEase of comprehension.\nImproved interoperability.\nHelps implementers and maintainers.\n\n##### Note\n\nThis is a specific variant of the general rule that [a concept must make semantic sense](#rt-low).\n\n##### Example, bad\n\n    template<typename T> concept Subtractable = requires(T a, T b) { a - b; };\n\nThis makes no semantic sense.\nYou need at least `+` to make `-` meaningful and useful.\n\nExamples of complete sets are\n\n* `Arithmetic`: `+`, `-`, `*`, `/`, `+=`, `-=`, `*=`, `/=`\n* `Comparable`: `<`, `>`, `<=`, `>=`, `==`, `!=`\n\n##### Note\n\nThis rule applies whether we use direct language support for concepts or not.\nIt is a general design rule that even applies to non-templates:\n\n    class Minimal {\n        // ...\n    };\n\n    bool operator==(const Minimal&, const Minimal&);\n    bool operator<(const Minimal&, const Minimal&);\n\n    Minimal operator+(const Minimal&, const Minimal&);\n    // no other operators\n\n    void f(Minimal x, Minimal y)\n    {\n        if (!(x == y)) { /* ... */ }    // OK\n        if (x != y) { /* ... */ }       // surprise! error\n\n        while (!(x < y)) { /* ... */ }  // OK\n        while (x >= y) { /* ... */ }    // surprise! error\n\n        x = x + y;          // OK\n        x += y;             // surprise! error\n    }\n\nThis is minimal, but surprising and constraining for users.\nIt could even be less efficient.\n\nThe rule supports the view that a concept should reflect a (mathematically) coherent set of operations.\n\n##### Example\n\n    class Convenient {\n        // ...\n    };\n\n    bool operator==(const Convenient&, const Convenient&);\n    bool operator<(const Convenient&, const Convenient&);\n    // ... and the other comparison operators ...\n\n    Convenient operator+(const Convenient&, const Convenient&);\n    // ... and the other arithmetic operators ...\n\n    void f(const Convenient& x, const Convenient& y)\n    {\n        if (!(x == y)) { /* ... */ }    // OK\n        if (x != y) { /* ... */ }       // OK\n\n        while (!(x < y)) { /* ... */ }  // OK\n        while (x >= y) { /* ... */ }    // OK\n\n        x = x + y;     // OK\n        x += y;        // OK\n    }\n\nIt can be a nuisance to define all operators, but not hard.\nIdeally, that rule should be language supported by giving you comparison operators by default.\n\n##### Enforcement\n\n* Flag classes that support \"odd\" subsets of a set of operators, e.g., `==` but not `!=` or `+` but not `-`.\n  Yes, `std::string` is \"odd\", but it's too late to change that.\n\n\n### <a name=\"rt-axiom\"></a>T.22: Specify axioms for concepts\n\n##### Reason\n\nA meaningful/useful concept has a semantic meaning.\nExpressing these semantics in an informal, semi-formal, or formal way makes the concept comprehensible to readers and the effort to express it can catch conceptual errors.\nSpecifying semantics is a powerful design tool.\n\n##### Example\n\n    template<typename T>\n        // The operators +, -, *, and / for a number are assumed to follow the usual mathematical rules\n        // axiom(T a, T b) { a + b == b + a; a - a == 0; a * (b + c) == a * b + a * c; /*...*/ }\n        concept Number = requires(T a, T b) {\n            { a + b } -> convertible_to<T>;\n            { a - b } -> convertible_to<T>;\n            { a * b } -> convertible_to<T>;\n            { a / b } -> convertible_to<T>;\n        };\n\n##### Note\n\nThis is an axiom in the mathematical sense: something that can be assumed without proof.\nIn general, axioms are not provable, and when they are the proof is often beyond the capability of a compiler.\nAn axiom might not be general, but the template writer can assume that it holds for all inputs actually used (similar to a precondition).\n\n##### Note\n\nIn this context axioms are Boolean expressions.\nSee the [Palo Alto TR](#s-references) for examples.\nCurrently, C++ does not support axioms (even the ISO Concepts TS), so we have to make do with comments for a longish while.\nOnce language support is available, the `//` in front of the axiom can be removed\n\n##### Note\n\nThe GSL concepts have well-defined semantics; see the Palo Alto TR and the Ranges TS.\n\n##### Exception\n\nEarly versions of a new \"concept\" still under development will often just define simple sets of constraints without a well-specified semantics.\nFinding good semantics can take effort and time.\nAn incomplete set of constraints can still be very useful:\n\n    // balancer for a generic binary tree\n    template<typename Node> concept Balancer = requires(Node* p) {\n        add_fixup(p);\n        touch(p);\n        detach(p);\n    };\n\nSo a `Balancer` must supply at least these operations on a tree `Node`,\nbut we are not yet ready to specify detailed semantics because a new kind of balanced tree might require more operations\nand the precise general semantics for all nodes is hard to pin down in the early stages of design.\n\nA \"concept\" that is incomplete or without a well-specified semantics can still be useful.\nFor example, it allows for some checking during initial experimentation.\nHowever, it should not be assumed to be stable.\nEach new use case might require such an incomplete concept to be improved.\n\n##### Enforcement\n\n* Look for the word \"axiom\" in concept definition comments\n\n### <a name=\"rt-refine\"></a>T.23: Differentiate a refined concept from its more general case by adding new use patterns.\n\n##### Reason\n\nOtherwise they cannot be distinguished automatically by the compiler.\n\n##### Example\n\n    template<typename I>\n    // Note: input_iterator is defined in <iterator>\n    concept Input_iter = requires(I iter) { ++iter; };\n\n    template<typename I>\n    // Note: forward_iterator is defined in <iterator>\n    concept Fwd_iter = Input_iter<I> && requires(I iter) { iter++; };\n\nThe compiler can determine refinement based on the sets of required operations (here, suffix `++`).\nThis decreases the burden on implementers of these types since\nthey do not need any special declarations to \"hook into the concept\".\nIf two concepts have exactly the same requirements, they are logically equivalent (there is no refinement).\n\n##### Enforcement\n\n* Flag a concept that has exactly the same requirements as another already-seen concept (neither is more refined).\nTo disambiguate them, see [T.24](#rt-tag).\n\n### <a name=\"rt-tag\"></a>T.24: Use tag classes or traits to differentiate concepts that differ only in semantics.\n\n##### Reason\n\nTwo concepts requiring the same syntax but having different semantics lead to ambiguity unless the programmer differentiates them.\n\n##### Example\n\n    template<typename I>    // iterator providing random access\n    // Note: random_access_iterator is defined in <iterator>\n    concept RA_iter = ...;\n\n    template<typename I>    // iterator providing random access to contiguous data\n    // Note: contiguous_iterator is defined in <iterator>\n    concept Contiguous_iter =\n        RA_iter<I> && is_contiguous_v<I>;  // using is_contiguous trait\n\nThe programmer (in a library) must define `is_contiguous` (a trait) appropriately.\n\nWrapping a tag class into a concept leads to a simpler expression of this idea:\n\n    template<typename I> concept Contiguous = is_contiguous_v<I>;\n\n    template<typename I>\n    concept Contiguous_iter = RA_iter<I> && Contiguous<I>;\n\nThe programmer (in a library) must define `is_contiguous` (a trait) appropriately.\n\n##### Note\n\nTraits can be trait classes or type traits.\nThese can be user-defined or standard-library ones.\nPrefer the standard-library ones.\n\n##### Enforcement\n\n* The compiler flags ambiguous use of identical concepts.\n* Flag the definition of identical concepts.\n\n### <a name=\"rt-not\"></a>T.25: Avoid complementary constraints\n\n##### Reason\n\nClarity. Maintainability.\nFunctions with complementary requirements expressed using negation are brittle.\n\n##### Example\n\nInitially, people will try to define functions with complementary requirements:\n\n    template<typename T>\n        requires !C<T>    // bad\n    void f();\n\n    template<typename T>\n        requires C<T>\n    void f();\n\nThis is better:\n\n    template<typename T>   // general template\n        void f();\n\n    template<typename T>   // specialization by concept\n        requires C<T>\n    void f();\n\nThe compiler will choose the unconstrained template only when `C<T>` is\nunsatisfied. If you do not want to (or cannot) define an unconstrained\nversion of `f()`, then delete it.\n\n    template<typename T>\n    void f() = delete;\n\nThe compiler will select the overload, or emit an appropriate error.\n\n##### Note\n\nComplementary constraints are unfortunately common in `enable_if` code:\n\n    template<typename T>\n    enable_if<!C<T>, void>   // bad\n    f();\n\n    template<typename T>\n    enable_if<C<T>, void>\n    f();\n\n\n##### Note\n\nComplementary requirements on one requirement are sometimes (wrongly) considered manageable.\nHowever, for two or more requirements the number of definitions needs can go up exponentially (2,4,8,16,...):\n\n    C1<T> && C2<T>\n    !C1<T> && C2<T>\n    C1<T> && !C2<T>\n    !C1<T> && !C2<T>\n\nNow the opportunities for errors multiply.\n\n##### Enforcement\n\n* Flag pairs of functions with `C<T>` and `!C<T>` constraints\n\n### <a name=\"rt-use\"></a>T.26: Prefer to define concepts in terms of use-patterns rather than simple syntax\n\n##### Reason\n\nThe definition is more readable and corresponds directly to what a user has to write.\nConversions are taken into account. You don't have to remember the names of all the type traits.\n\n##### Example\n\nYou might be tempted to define a concept `Equality` like this:\n\n    template<typename T> concept Equality = has_equal<T> && has_not_equal<T>;\n\nObviously, it would be better and easier just to use the standard `equality_comparable`,\nbut - just as an example - if you had to define such a concept, prefer:\n\n    template<typename T> concept Equality = requires(T a, T b) {\n        { a == b } -> std::convertible_to<bool>;\n        { a != b } -> std::convertible_to<bool>;\n        // axiom { !(a == b) == (a != b) }\n        // axiom { a = b; => a == b }  // => means \"implies\"\n    };\n\nas opposed to defining two meaningless concepts `has_equal` and `has_not_equal` just as helpers in the definition of `Equality`.\nBy \"meaningless\" we mean that we cannot specify the semantics of `has_equal` in isolation.\n\n##### Enforcement\n\n???\n\n## <a name=\"ss-temp-interface\"></a>Template interfaces\n\nOver the years, programming with templates has suffered from a weak distinction between the interface of a template\nand its implementation.\nBefore concepts, that distinction had no direct language support.\nHowever, the interface to a template is a critical concept - a contract between a user and an implementer - and should be carefully designed.\n\n### <a name=\"rt-fo\"></a>T.40: Use function objects to pass operations to algorithms\n\n##### Reason\n\nFunction objects can carry more information through an interface than a \"plain\" pointer to function.\nIn general, passing function objects gives better performance than passing pointers to functions.\n\n##### Example\n\n    bool greater(double x, double y) { return x > y; }\n    sort(v, greater);                                    // pointer to function: potentially slow\n    sort(v, [](double x, double y) { return x > y; });   // function object\n    sort(v, std::greater{});                             // function object\n\n    bool greater_than_7(double x) { return x > 7; }\n    auto x = find_if(v, greater_than_7);                 // pointer to function: inflexible\n    auto y = find_if(v, [](double x) { return x > 7; }); // function object: carries the needed data\n    auto z = find_if(v, Greater_than<double>(7));        // function object: carries the needed data\n\nYou can, of course, generalize those functions using `auto` or concepts. For example:\n\n    auto y1 = find_if(v, [](totally_ordered auto x) { return x > 7; }); // require an ordered type\n    auto z1 = find_if(v, [](auto x) { return x > 7; });                 // hope that the type has a >\n\n##### Note\n\nLambdas generate function objects.\n\n##### Note\n\nThe performance argument depends on compiler and optimizer technology.\n\n##### Enforcement\n\n* Flag pointer to function template arguments.\n* Flag pointers to functions passed as arguments to a template (risk of false positives).\n\n\n### <a name=\"rt-essential\"></a>T.41: Require only essential properties in a template's concepts\n\n##### Reason\n\nKeep interfaces simple and stable.\n\n##### Example\n\nConsider, a `sort` instrumented with (oversimplified) simple debug support:\n\n    void sort(sortable auto& s)  // sort sequence s\n    {\n        if (debug) cerr << \"enter sort( \" << s <<  \")\\n\";\n        // ...\n        if (debug) cerr << \"exit sort( \" << s <<  \")\\n\";\n    }\n\nShould this be rewritten to:\n\n    template<sortable S>\n        requires Streamable<S>\n    void sort(S& s)  // sort sequence s\n    {\n        if (debug) cerr << \"enter sort( \" << s <<  \")\\n\";\n        // ...\n        if (debug) cerr << \"exit sort( \" << s <<  \")\\n\";\n    }\n\nAfter all, there is nothing in `sortable` that requires `iostream` support.\nOn the other hand, there is nothing in the fundamental idea of sorting that says anything about debugging.\n\n##### Note\n\nIf we require every operation used to be listed among the requirements, the interface becomes unstable:\nEvery time we change the debug facilities, the usage data gathering, testing support, error reporting, etc.,\nthe definition of the template would need change and every use of the template would have to be recompiled.\nThis is cumbersome, and in some environments infeasible.\n\nConversely, if we use an operation in the implementation that is not guaranteed by concept checking,\nwe might get a late compile-time error.\n\nBy not using concept checking for properties of a template argument that is not considered essential,\nwe delay checking until instantiation time.\nWe consider this a worthwhile tradeoff.\n\nNote that using non-local, non-dependent names (such as `debug` and `cerr`) also introduces context dependencies that might lead to \"mysterious\" errors.\n\n##### Note\n\nIt can be hard to decide which properties of a type are essential and which are not.\n\n##### Enforcement\n\n???\n\n### <a name=\"rt-alias\"></a>T.42: Use template aliases to simplify notation and hide implementation details\n\n##### Reason\n\nImproved readability.\nImplementation hiding.\nNote that template aliases replace many uses of traits to compute a type.\nThey can also be used to wrap a trait.\n\n##### Example\n\n    template<typename T, size_t N>\n    class Matrix {\n        // ...\n        using Iterator = typename std::vector<T>::iterator;\n        // ...\n    };\n\nThis saves the user of `Matrix` from having to know that its elements are stored in a `vector` and also saves the user from repeatedly typing `typename std::vector<T>::`.\n\n##### Example\n\n    template<typename T>\n    void user(T& c)\n    {\n        // ...\n        typename container_traits<T>::value_type x; // bad, verbose\n        // ...\n    }\n\n    template<typename T>\n    using Value_type = typename container_traits<T>::value_type;\n\n\nThis saves the user of `Value_type` from having to know the technique used to implement `value_type`s.\n\n    template<typename T>\n    void user2(T& c)\n    {\n        // ...\n        Value_type<T> x;\n        // ...\n    }\n\n##### Note\n\nA simple, common use could be expressed: \"Wrap traits!\"\n\n##### Enforcement\n\n* Flag use of `typename` as a disambiguator outside `using` declarations.\n* ???\n\n### <a name=\"rt-using\"></a>T.43: Prefer `using` over `typedef` for defining aliases\n\n##### Reason\n\nImproved readability: With `using`, the new name comes first rather than being embedded somewhere in a declaration.\nGenerality: `using` can be used for template aliases, whereas `typedef`s can't easily be templates.\nUniformity: `using` is syntactically similar to `auto`.\n\n##### Example\n\n    typedef int (*PFI)(int);   // OK, but convoluted\n\n    using PFI2 = int (*)(int);   // OK, preferred\n\n    template<typename T>\n    typedef int (*PFT)(T);      // error\n\n    template<typename T>\n    using PFT2 = int (*)(T);   // OK\n\n##### Enforcement\n\n* Flag uses of `typedef`. This will give a lot of \"hits\" :-(\n\n### <a name=\"rt-deduce\"></a>T.44: Use function templates to deduce class template argument types (where feasible)\n\n##### Reason\n\nWriting the template argument types explicitly can be tedious and unnecessarily verbose.\n\n##### Example\n\n    tuple<int, string, double> t1 = {1, \"Hamlet\", 3.14};   // explicit type\n    auto t2 = make_tuple(1, \"Ophelia\"s, 3.14);         // better; deduced type\n\nNote the use of the `s` suffix to ensure that the string is a `std::string`, rather than a C-style string.\n\n##### Note\n\nSince you can trivially write a `make_T` function, so could the compiler. Thus, `make_T` functions might become redundant in the future.\n\n##### Exception\n\nSometimes there isn't a good way of getting the template arguments deduced and sometimes, you want to specify the arguments explicitly:\n\n    vector<double> v = { 1, 2, 3, 7.9, 15.99 };\n    list<Record*> lst;\n\n##### Note\n\nNote that C++17 will make this rule redundant by allowing the template arguments to be deduced directly from constructor arguments:\n[Template parameter deduction for constructors (Rev. 3)](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0091r1.html).\nFor example:\n\n    tuple t1 = {1, \"Hamlet\"s, 3.14}; // deduced: tuple<int, string, double>\n\n##### Enforcement\n\nFlag uses where an explicitly specialized type exactly matches the types of the arguments used.\n\n### <a name=\"rt-regular\"></a>T.46: Require template arguments to be at least semiregular\n\n##### Reason\n\nReadability.\nPreventing surprises and errors.\nMost uses support that anyway.\n\n##### Example\n\n    class X {\n    public:\n        explicit X(int);\n        X(const X&);            // copy\n        X operator=(const X&);\n        X(X&&) noexcept;        // move\n        X& operator=(X&&) noexcept;\n        ~X();\n        // ... no more constructors ...\n    };\n\n    X x {1};              // fine\n    X y = x;              // fine\n    std::vector<X> v(10); // error: no default constructor\n\n##### Note\n\nSemiregular requires default constructible.\n\n##### Enforcement\n\n* Flag types used as template arguments that are not at least semiregular.\n\n### <a name=\"rt-visible\"></a>T.47: Avoid highly visible unconstrained templates with common names\n\n##### Reason\n\n An unconstrained template argument is a perfect match for anything so such a template can be preferred over more specific types that require minor conversions.\n This is particularly annoying/dangerous when ADL is used.\n Common names make this problem more likely.\n\n##### Example\n\n    namespace Bad {\n        struct S { int m; };\n        template<typename T1, typename T2>\n        bool operator==(T1, T2) { cout << \"Bad\\n\"; return true; }\n    }\n\n    namespace T0 {\n        bool operator==(int, Bad::S) { cout << \"T0\\n\"; return true; }  // compare to int\n\n        void test()\n        {\n            Bad::S bad{ 1 };\n            vector<int> v(10);\n            bool b = 1 == bad;\n            bool b2 = v.size() == bad;\n        }\n    }\n\nThis prints `T0` and `Bad`.\n\nNow the `==` in `Bad` was designed to cause trouble, but would you have spotted the problem in real code?\nThe problem is that `v.size()` returns an `unsigned` integer so that a conversion is needed to call the local `==`;\nthe `==` in `Bad` requires no conversions.\nRealistic types, such as the standard-library iterators can be made to exhibit similar anti-social tendencies.\n\n##### Note\n\nIf an unconstrained template is defined in the same namespace as a type,\nthat unconstrained template can be found by ADL (as happened in the example).\nThat is, it is highly visible.\n\n##### Note\n\nThis rule should not be necessary, but the committee cannot agree to exclude unconstrained templates from ADL.\n\nUnfortunately this will get many false positives; the standard library violates this widely, by putting many unconstrained templates and types into the single namespace `std`.\n\n\n##### Enforcement\n\nFlag templates defined in a namespace where concrete types are also defined (maybe not feasible until we have concepts).\n\n\n### <a name=\"rt-concept-def\"></a>T.48: If your compiler does not support concepts, fake them with `enable_if`\n\n##### Reason\n\nBecause that's the best we can do without direct concept support.\n`enable_if` can be used to conditionally define functions and to select among a set of functions.\n\n##### Example\n\n    template<typename T>\n    enable_if_t<is_integral_v<T>>\n    f(T v)\n    {\n        // ...\n    }\n\n    // Equivalent to:\n    template<Integral T>\n    void f(T v)\n    {\n        // ...\n    }\n\n##### Note\n\nBeware of [complementary constraints](#rt-not).\nFaking concept overloading using `enable_if` sometimes forces us to use that error-prone design technique.\n\n##### Enforcement\n\n???\n\n### <a name=\"rt-erasure\"></a>T.49: Where possible, avoid type-erasure\n\n##### Reason\n\nType erasure incurs an extra level of indirection by hiding type information behind a separate compilation boundary.\n\n##### Example\n\n    ???\n\n**Exceptions**: Type erasure is sometimes appropriate, such as for `std::function`.\n\n##### Enforcement\n\n???\n\n\n##### Note\n\n\n## <a name=\"ss-temp-def\"></a>T.def: Template definitions\n\nA template definition (class or function) can contain arbitrary code, so only a comprehensive review of C++ programming techniques would cover this topic.\nHowever, this section focuses on what is specific to template implementation.\nIn particular, it focuses on a template definition's dependence on its context.\n\n### <a name=\"rt-depend\"></a>T.60: Minimize a template's context dependencies\n\n##### Reason\n\nEases understanding.\nMinimizes errors from unexpected dependencies.\nEases tool creation.\n\n##### Example\n\n    template<typename C>\n    void sort(C& c)\n    {\n        std::sort(begin(c), end(c)); // necessary and useful dependency\n    }\n\n    template<typename Iter>\n    Iter algo(Iter first, Iter last)\n    {\n        for (; first != last; ++first) {\n            auto x = sqrt(*first); // potentially surprising dependency: which sqrt()?\n            helper(first, x);      // potentially surprising dependency:\n                                   // helper is chosen based on first and x\n            TT var = 7;            // potentially surprising dependency: which TT?\n        }\n    }\n\n##### Note\n\nTemplates typically appear in header files so their context dependencies are more vulnerable to `#include` order dependencies than functions in `.cpp` files.\n\n##### Note\n\nHaving a template operate only on its arguments would be one way of reducing the number of dependencies to a minimum, but that would generally be unmanageable.\nFor example, algorithms usually use other algorithms and invoke operations that do not exclusively operate on arguments.\nAnd don't get us started on macros!\n\n**See also**: [T.69](#rt-customization)\n\n##### Enforcement\n\n??? Tricky\n\n### <a name=\"rt-scary\"></a>T.61: Do not over-parameterize members (SCARY)\n\n##### Reason\n\nA member that does not depend on a template parameter cannot be used except for a specific template argument.\nThis limits use and typically increases code size.\n\n##### Example, bad\n\n    template<typename T, typename A = std::allocator<T>>\n        // requires Regular<T> && Allocator<A>\n    class List {\n    public:\n        struct Link {   // does not depend on A\n            T elem;\n            Link* pre;\n            Link* suc;\n        };\n\n        using iterator = Link*;\n\n        iterator first() const { return head; }\n\n        // ...\n    private:\n        Link* head;\n    };\n\n    List<int> lst1;\n    List<int, My_allocator> lst2;\n\nThis looks innocent enough, but now `Link` formally depends on the allocator (even though it doesn't use the allocator). This forces redundant instantiations that can be surprisingly costly in some real-world scenarios.\nTypically, the solution is to make what would have been a nested class non-local, with its own minimal set of template parameters.\n\n    template<typename T>\n    struct Link {\n        T elem;\n        Link* pre;\n        Link* suc;\n    };\n\n    template<typename T, typename A = std::allocator<T>>\n        // requires Regular<T> && Allocator<A>\n    class List2 {\n    public:\n        using iterator = Link<T>*;\n\n        iterator first() const { return head; }\n\n        // ...\n    private:\n        Link<T>* head;\n    };\n\n    List2<int> lst1;\n    List2<int, My_allocator> lst2;\n\nSome people found the idea that the `Link` no longer was hidden inside the list scary, so we named the technique\n[SCARY](https://www.open-std.org/jtc1/sc22/WG21/docs/papers/2009/n2911.pdf). From that academic paper:\n\"The acronym SCARY describes assignments and initializations that are Seemingly erroneous (appearing Constrained by conflicting generic parameters), but Actually work with the Right implementation (unconstrained bY the conflict due to minimized dependencies).\"\n\n##### Note\n\nThis also applies to lambdas that don't depend on all of the template parameters.\n\n##### Enforcement\n\n* Flag member types that do not depend on every template parameter\n* Flag member functions that do not depend on every template parameter\n* Flag lambdas or variable templates that do not depend on every template parameter\n\n### <a name=\"rt-nondependent\"></a>T.62: Place non-dependent class template members in a non-templated base class\n\n##### Reason\n\n Allow the base class members to be used without specifying template arguments and without template instantiation.\n\n##### Example\n\n    template<typename T>\n    class Foo {\n    public:\n        enum { v1, v2 };\n        // ...\n    };\n\n???\n\n    struct Foo_base {\n        enum { v1, v2 };\n        // ...\n    };\n\n    template<typename T>\n    class Foo : public Foo_base {\n    public:\n        // ...\n    };\n\n##### Note\n\nA more general version of this rule would be\n\"If a class template member depends on only N template parameters out of M, place it in a base class with only N parameters.\"\nFor N == 1, we have a choice of a base class of a class in the surrounding scope as in [T.61](#rt-scary).\n\n??? What about constants? class statics?\n\n##### Enforcement\n\n* Flag ???\n\n### <a name=\"rt-specialization\"></a>T.64: Use specialization to provide alternative implementations of class templates\n\n##### Reason\n\nA template defines a general interface.\nSpecialization offers a powerful mechanism for providing alternative implementations of that interface.\n\n##### Example\n\n    ??? string specialization (==)\n\n    ??? representation specialization ?\n\n##### Note\n\n???\n\n##### Enforcement\n\n???\n\n### <a name=\"rt-tag-dispatch\"></a>T.65: Use tag dispatch to provide alternative implementations of a function\n\n##### Reason\n\n* A template defines a general interface.\n* Tag dispatch allows us to select implementations based on specific properties of an argument type.\n* Performance.\n\n##### Example\n\nThis is a simplified version of `std::copy` (ignoring the possibility of non-contiguous sequences)\n\n    struct trivially_copyable_tag {};\n    struct non_trivially_copyable_tag {};\n\n    // T is not trivially copyable\n    template<class T> struct copy_trait { using tag = non_trivially_copyable_tag; };\n    // int is trivially copyable\n    template<> struct copy_trait<int> { using tag = trivially_copyable_tag; };\n\n    template<class Iter>\n    Out copy_helper(Iter first, Iter last, Iter out, trivially_copyable_tag)\n    {\n        // use memmove\n    }\n\n    template<class Iter>\n    Out copy_helper(Iter first, Iter last, Iter out, non_trivially_copyable_tag)\n    {\n        // use loop calling copy constructors\n    }\n\n    template<class Iter>\n    Out copy(Iter first, Iter last, Iter out)\n    {\n        using tag_type = typename copy_trait<std::iter_value_t<Iter>>::tag;\n        return copy_helper(first, last, out, tag_type{})\n    }\n\n    void use(vector<int>& vi, vector<int>& vi2, vector<string>& vs, vector<string>& vs2)\n    {\n        copy(vi.begin(), vi.end(), vi2.begin()); // uses memmove\n        copy(vs.begin(), vs.end(), vs2.begin()); // uses a loop calling copy constructors\n    }\n\nThis is a general and powerful technique for compile-time algorithm selection.\n\n##### Note\n\nWith C++20 constraints, such alternatives can be distinguished directly:\n\n    template<class Iter>\n        requires std::is_trivially_copyable_v<std::iter_value_t<Iter>>\n    Out copy_helper(In, first, In last, Out out)\n    {\n        // use memmove\n    }\n\n    template<class Iter>\n    Out copy_helper(In, first, In last, Out out)\n    {\n        // use loop calling copy constructors\n    }\n\n##### Enforcement\n\n???\n\n\n### <a name=\"rt-specialization2\"></a>T.67: Use specialization to provide alternative implementations for irregular types\n\n##### Reason\n\n ???\n\n##### Example\n\n    ???\n\n##### Enforcement\n\n???\n\n### <a name=\"rt-cast\"></a>T.68: Use `{}` rather than `()` within templates to avoid ambiguities\n\n##### Reason\n\n`()` is vulnerable to grammar ambiguities.\n\n##### Example\n\n    template<typename T, typename U>\n    void f(T t, U u)\n    {\n        T v1(T(u));    // mistake: oops, v1 is a function, not a variable\n        T v2{u};       // clear:   obviously a variable\n        auto x = T(u); // unclear: construction or cast?\n    }\n\n    f(1, \"asdf\"); // bad: cast from const char* to int\n\n##### Enforcement\n\n* flag `()` initializers\n* flag function-style casts\n\n\n### <a name=\"rt-customization\"></a>T.69: Inside a template, don't make an unqualified non-member function call unless you intend it to be a customization point\n\n##### Reason\n\n* Provide only intended flexibility.\n* Avoid vulnerability to accidental environmental changes.\n\n##### Example\n\nThere are three major ways to let calling code customize a template.\n\n    template<class T>\n        // Call a member function\n    void test1(T t)\n    {\n        t.f();    // require T to provide f()\n    }\n\n    template<class T>\n    void test2(T t)\n        // Call a non-member function without qualification\n    {\n        f(t);     // require f(/*T*/) be available in caller's scope or in T's namespace\n    }\n\n    template<class T>\n    void test3(T t)\n        // Invoke a \"trait\"\n    {\n        test_traits<T>::f(t); // require customizing test_traits<>\n                              // to get non-default functions/types\n    }\n\nA trait is usually a type alias to compute a type,\na `constexpr` function to compute a value,\nor a traditional traits template to be specialized on the user's type.\n\n##### Note\n\nIf you intend to call your own helper function `helper(t)` with a value `t` that depends on a template type parameter,\nput it in a `::detail` namespace and qualify the call as `detail::helper(t);`.\nAn unqualified call becomes a customization point where any function `helper` in the namespace of `t`'s type can be invoked;\nthis can cause problems like [unintentionally invoking unconstrained function templates](#rt-visible).\n\n\n##### Enforcement\n\n* In a template, flag an unqualified call to a non-member function that passes a variable of dependent type when there is a non-member function of the same name in the template's namespace.\n\n\n## <a name=\"ss-temp-hier\"></a>T.temp-hier: Template and hierarchy rules:\n\nTemplates are the backbone of C++'s support for generic programming and class hierarchies the backbone of its support\nfor object-oriented programming.\nThe two language mechanisms can be used effectively in combination, but a few design pitfalls must be avoided.\n\n### <a name=\"rt-hier\"></a>T.80: Do not naively templatize a class hierarchy\n\n##### Reason\n\nTemplating a class hierarchy that has many functions, especially many virtual functions, can lead to code bloat.\n\n##### Example, bad\n\n    template<typename T>\n    struct Container {         // an interface\n        virtual T* get(int i);\n        virtual T* first();\n        virtual T* next();\n        virtual void sort();\n    };\n\n    template<typename T>\n    class Vector : public Container<T> {\n    public:\n        // ...\n    };\n\n    Vector<int> vi;\n    Vector<string> vs;\n\nIt is probably a bad idea to define a `sort` as a member function of a container, but it is not unheard of and it makes a good example of what not to do.\n\nGiven this, the compiler cannot know if `vector<int>::sort()` is called, so it must generate code for it.\nSimilar for `vector<string>::sort()`.\nUnless those two functions are called that's code bloat.\nImagine what this would do to a class hierarchy with dozens of member functions and dozens of derived classes with many instantiations.\n\n##### Note\n\nIn many cases you can provide a stable interface by not parameterizing a base;\nsee [\"stable base\"](#rt-abi) and [OO and GP](#rt-generic-oo)\n\n##### Enforcement\n\n* Flag virtual functions that depend on a template argument. ??? False positives\n\n### <a name=\"rt-array\"></a>T.81: Do not mix hierarchies and arrays\n\n##### Reason\n\nAn array of derived classes can implicitly \"decay\" to a pointer to a base class with potential disastrous results.\n\n##### Example\n\nAssume that `Apple` and `Pear` are two kinds of `Fruit`s.\n\n    void maul(Fruit* p)\n    {\n        *p = Pear{};     // put a Pear into *p\n        p[1] = Pear{};   // put a Pear into p[1]\n    }\n\n    Apple aa [] = { an_apple, another_apple };   // aa contains Apples (obviously!)\n\n    maul(aa);\n    Apple& a0 = &aa[0];   // a Pear?\n    Apple& a1 = &aa[1];   // a Pear?\n\nProbably, `aa[0]` will be a `Pear` (without the use of a cast!).\nIf `sizeof(Apple) != sizeof(Pear)` the access to `aa[1]` will not be aligned to the proper start of an object in the array.\nWe have a type violation and possibly (probably) a memory corruption.\nNever write such code.\n\nNote that `maul()` violates the a [`T*` points to an individual object rule](#rf-ptr).\n\n**Alternative**: Use a proper (templatized) container:\n\n    void maul2(Fruit* p)\n    {\n        *p = Pear{};   // put a Pear into *p\n    }\n\n    vector<Apple> va = { an_apple, another_apple };   // va contains Apples (obviously!)\n\n    maul2(va);       // error: cannot convert a vector<Apple> to a Fruit*\n    maul2(&va[0]);   // you asked for it\n\n    Apple& a0 = &va[0];   // a Pear?\n\nNote that the assignment in `maul2()` violated the [no-slicing rule](#res-slice).\n\n##### Enforcement\n\n* Detect this horror!\n\n### <a name=\"rt-linear\"></a>T.82: Linearize a hierarchy when virtual functions are undesirable\n\n##### Reason\n\n ???\n\n##### Example\n\n    ???\n\n##### Enforcement\n\n???\n\n### <a name=\"rt-virtual\"></a>T.83: Do not declare a member function template virtual\n\n##### Reason\n\nC++ does not support that.\nIf it did, vtbls could not be generated until link time.\nAnd in general, implementations must deal with dynamic linking.\n\n##### Example, don't\n\n    class Shape {\n        // ...\n        template<class T>\n        virtual bool intersect(T* p);   // error: template cannot be virtual\n    };\n\n##### Note\n\nWe need a rule because people keep asking about this\n\n##### Alternative\n\nDouble dispatch, visitors, calculate which function to call\n\n##### Enforcement\n\nThe compiler handles that.\n\n### <a name=\"rt-abi\"></a>T.84: Use a non-template core implementation to provide an ABI-stable interface\n\n##### Reason\n\nImprove stability of code.\nAvoid code bloat.\n\n##### Example\n\nIt could be a base class:\n\n    struct Link_base {   // stable\n        Link_base* suc;\n        Link_base* pre;\n    };\n\n    template<typename T>   // templated wrapper to add type safety\n    struct Link : Link_base {\n        T val;\n    };\n\n    struct List_base {\n        Link_base* first;   // first element (if any)\n        int sz;             // number of elements\n        void add_front(Link_base* p);\n        // ...\n    };\n\n    template<typename T>\n    class List : List_base {\n    public:\n        void put_front(const T& e) { add_front(new Link<T>{e}); }   // implicit cast to Link_base\n        T& front() { return static_cast<Link<T>*>(first)->val; }   // explicit cast back to Link<T>\n        // ...\n    };\n\n    List<int> li;\n    List<string> ls;\n\nNow there is only one copy of the operations linking and unlinking elements of a `List`.\nThe `Link` and `List` classes do nothing but type manipulation.\n\nInstead of using a separate \"base\" type, another common technique is to specialize for `void` or `void*` and have the general template for `T` be just the safely-encapsulated casts to and from the core `void` implementation.\n\n**Alternative**: Use a [Pimpl](#ri-pimpl) implementation.\n\n##### Enforcement\n\n???\n\n## <a name=\"ss-variadic\"></a>T.var: Variadic template rules\n\n???\n\n### <a name=\"rt-variadic\"></a>T.100: Use variadic templates when you need a function that takes a variable number of arguments of a variety of types\n\n##### Reason\n\nVariadic templates is the most general mechanism for that, and is both efficient and type-safe. Don't use C varargs.\n\n##### Example\n\n    ??? printf\n\n##### Enforcement\n\n* Flag uses of `va_arg` in user code.\n\n### <a name=\"rt-variadic-pass\"></a>T.101: ??? How to pass arguments to a variadic template ???\n\n##### Reason\n\n ???\n\n##### Example\n\n    ??? beware of move-only and reference arguments\n\n##### Enforcement\n\n???\n\n### <a name=\"rt-variadic-process\"></a>T.102: How to process arguments to a variadic template\n\n##### Reason\n\n ???\n\n##### Example\n\n    ??? forwarding, type checking, references\n\n##### Enforcement\n\n???\n\n### <a name=\"rt-variadic-not\"></a>T.103: Don't use variadic templates for homogeneous argument lists\n\n##### Reason\n\nThere are more precise ways of specifying a homogeneous sequence, such as an `initializer_list`.\n\n##### Example\n\n    ???\n\n##### Enforcement\n\n???\n\n## <a name=\"ss-meta\"></a>T.meta: Template metaprogramming (TMP)\n\nTemplates provide a general mechanism for compile-time programming.\n\nMetaprogramming is programming where at least one input or one result is a type.\nTemplates offer Turing-complete (modulo memory capacity) duck typing at compile time.\nThe syntax and techniques needed are pretty horrendous.\n\n### <a name=\"rt-metameta\"></a>T.120: Use template metaprogramming only when you really need to\n\n##### Reason\n\nTemplate metaprogramming is hard to get right, slows down compilation, and is often very hard to maintain.\nHowever, there are real-world examples where template metaprogramming provides better performance than any alternative short of expert-level assembly code.\nAlso, there are real-world examples where template metaprogramming expresses the fundamental ideas better than run-time code.\nFor example, if you really need AST manipulation at compile time (e.g., for optional matrix operation folding) there might be no other way in C++.\n\n##### Example, bad\n\n    ???\n\n##### Example, bad\n\n    enable_if\n\nInstead, use concepts. But see [How to emulate concepts if you don't have language support](#rt-emulate).\n\n##### Example\n\n    ??? good\n\n**Alternative**: If the result is a value, rather than a type, use a [`constexpr` function](#rt-fct).\n\n##### Note\n\nIf you feel the need to hide your template metaprogramming in macros, you have probably gone too far.\n\n### <a name=\"rt-emulate\"></a>T.121: Use template metaprogramming primarily to emulate concepts\n\n##### Reason\n\nWhere C++20 is not available, we need to emulate them using TMP.\nUse cases that require concepts (e.g. overloading based on concepts) are among the most common (and simple) uses of TMP.\n\n##### Example\n\n    template<typename Iter>\n        /*requires*/ enable_if<random_access_iterator<Iter>, void>\n    advance(Iter p, int n) { p += n; }\n\n    template<typename Iter>\n        /*requires*/ enable_if<forward_iterator<Iter>, void>\n    advance(Iter p, int n) { assert(n >= 0); while (n--) ++p;}\n\n##### Note\n\nSuch code is much simpler using concepts:\n\n    void advance(random_access_iterator auto p, int n) { p += n; }\n\n    void advance(forward_iterator auto p, int n) { assert(n >= 0); while (n--) ++p;}\n\n##### Enforcement\n\n???\n\n### <a name=\"rt-tmp\"></a>T.122: Use templates (usually template aliases) to compute types at compile time\n\n##### Reason\n\nTemplate metaprogramming is the only directly supported and half-way principled way of generating types at compile time.\n\n##### Note\n\n\"Traits\" techniques are mostly replaced by template aliases to compute types and `constexpr` functions to compute values.\n\n##### Example\n\n    ??? big object / small object optimization\n\n##### Enforcement\n\n???\n\n### <a name=\"rt-fct\"></a>T.123: Use `constexpr` functions to compute values at compile time\n\n##### Reason\n\nA function is the most obvious and conventional way of expressing the computation of a value.\nOften a `constexpr` function implies less compile-time overhead than alternatives.\n\n##### Note\n\n\"Traits\" techniques are mostly replaced by template aliases to compute types and `constexpr` functions to compute values.\n\n##### Example\n\n    template<typename T>\n        // requires Number<T>\n    constexpr T pow(T v, int n)   // power/exponential\n    {\n        T res = 1;\n        while (n--) res *= v;\n        return res;\n    }\n\n    constexpr auto f7 = pow(pi, 7);\n\n##### Enforcement\n\n* Flag template metaprograms yielding a value. These should be replaced with `constexpr` functions.\n\n### <a name=\"rt-std-tmp\"></a>T.124: Prefer to use standard-library TMP facilities\n\n##### Reason\n\nFacilities defined in the standard, such as `conditional`, `enable_if`, and `tuple`, are portable and can be assumed to be known.\n\n##### Example\n\n    ???\n\n##### Enforcement\n\n???\n\n### <a name=\"rt-lib\"></a>T.125: If you need to go beyond the standard-library TMP facilities, use an existing library\n\n##### Reason\n\nGetting advanced TMP facilities is not easy and using a library makes you part of a (hopefully supportive) community.\nWrite your own \"advanced TMP support\" only if you really have to.\n\n##### Example\n\n    ???\n\n##### Enforcement\n\n???\n\n## <a name=\"ss-temp-other\"></a>Other template rules\n\n### <a name=\"rt-name\"></a>T.140: If an operation can be reused, give it a name\n\nSee [F.10](#rf-name)\n\n### <a name=\"rt-lambda\"></a>T.141: Use an unnamed lambda if you need a simple function object in one place only\n\nSee [F.11](#rf-lambda)\n\n### <a name=\"rt-var\"></a>T.142?: Use template variables to simplify notation\n\n##### Reason\n\nImproved readability.\n\n##### Example\n\n    ???\n\n##### Enforcement\n\n???\n\n### <a name=\"rt-non-generic\"></a>T.143: Don't write unintentionally non-generic code\n\n##### Reason\n\nGenerality. Reusability. Don't gratuitously commit to details; use the most general facilities available.\n\n##### Example\n\nUse `!=` instead of `<` to compare iterators; `!=` works for more objects because it doesn't rely on ordering.\n\n    for (auto i = first; i < last; ++i) {   // less generic\n        // ...\n    }\n\n    for (auto i = first; i != last; ++i) {   // good; more generic\n        // ...\n    }\n\nOf course, range-`for` is better still where it does what you want.\n\n##### Example\n\nUse the least-derived class that has the functionality you need.\n\n    class Base {\n    public:\n        Bar f();\n        Bar g();\n    };\n\n    class Derived1 : public Base {\n    public:\n        Bar h();\n    };\n\n    class Derived2 : public Base {\n    public:\n        Bar j();\n    };\n\n    // bad, unless there is a specific reason for limiting to Derived1 objects only\n    void my_func(Derived1& param)\n    {\n        use(param.f());\n        use(param.g());\n    }\n\n    // good, uses only Base interface so only commit to that\n    void my_func(Base& param)\n    {\n        use(param.f());\n        use(param.g());\n    }\n\n##### Enforcement\n\n* Flag comparison of iterators using `<` instead of `!=`.\n* Flag `x.size() == 0` when `x.empty()` or `x.is_empty()` is available. Emptiness works for more containers than size(), because some containers don't know their size or are conceptually of unbounded size.\n* Flag functions that take a pointer or reference to a more-derived type but only use functions declared in a base type.\n\n### <a name=\"rt-specialize-function\"></a>T.144: Don't specialize function templates\n\n##### Reason\n\nYou can't partially specialize a function template per language rules. You can fully specialize a function template but you almost certainly want to overload instead -- because function template specializations don't participate in overloading, they don't act as you probably wanted. Rarely, you should actually specialize by delegating to a class template that you can specialize properly.\n\n##### Example\n\n    ???\n\n**Exceptions**: If you do have a valid reason to specialize a function template, just write a single function template that delegates to a class template, then specialize the class template (including the ability to write partial specializations).\n\n##### Enforcement\n\n* Flag all specializations of a function template. Overload instead.\n\n\n### <a name=\"rt-check-class\"></a>T.150: Check that a class matches a concept using `static_assert`\n\n##### Reason\n\nIf you intend for a class to match a concept, verifying that early saves users' pain.\n\n##### Example\n\n    class X {\n    public:\n        X() = delete;\n        X(const X&) = default;\n        X(X&&) = default;\n        X& operator=(const X&) = default;\n        // ...\n    };\n\nSomewhere, possibly in an implementation file, let the compiler check the desired properties of `X`:\n\n    static_assert(Default_constructible<X>);    // error: X has no default constructor\n    static_assert(Copyable<X>);                 // error: we forgot to define X's move constructor\n\n\n##### Enforcement\n\nNot feasible.\n\n# <a name=\"s-cpl\"></a>CPL: C-style programming\n\nC and C++ are closely related languages.\nThey both originate in \"Classic C\" from 1978 and have evolved in ISO committees since then.\nMany attempts have been made to keep them compatible, but neither is a subset of the other.\n\nC rule summary:\n\n* [CPL.1: Prefer C++ to C](#rcpl-c)\n* [CPL.2: If you must use C, use the common subset of C and C++, and compile the C code as C++](#rcpl-subset)\n* [CPL.3: If you must use C for interfaces, use C++ in the calling code using such interfaces](#rcpl-interface)\n\n### <a name=\"rcpl-c\"></a>CPL.1: Prefer C++ to C\n\n##### Reason\n\nC++ provides better type checking and more notational support.\nIt provides better support for high-level programming and often generates faster code.\n\n##### Example\n\n    char ch = 7;\n    void* pv = &ch;\n    int* pi = pv;   // not C++\n    *pi = 999;      // overwrite sizeof(int) bytes near &ch\n\nThe rules for implicit casting to and from `void*` in C are subtle and unenforced.\nIn particular, this example violates a rule against converting to a type with stricter alignment.\n\n##### Enforcement\n\nUse a C++ compiler.\n\n### <a name=\"rcpl-subset\"></a>CPL.2: If you must use C, use the common subset of C and C++, and compile the C code as C++\n\n##### Reason\n\nThat subset can be compiled with both C and C++ compilers, and when compiled as C++ is better type checked than \"pure C.\"\n\n##### Example\n\n    int* p1 = malloc(10 * sizeof(int));                      // not C++\n    int* p2 = static_cast<int*>(malloc(10 * sizeof(int)));   // not C, C-style C++\n    int* p3 = new int[10];                                   // not C\n    int* p4 = (int*) malloc(10 * sizeof(int));               // both C and C++\n\n##### Enforcement\n\n* Flag if using a build mode that compiles code as C.\n\n  * The C++ compiler will enforce that the code is valid C++ unless you use C extension options.\n\n### <a name=\"rcpl-interface\"></a>CPL.3: If you must use C for interfaces, use C++ in the calling code using such interfaces\n\n##### Reason\n\nC++ is more expressive than C and offers better support for many types of programming.\n\n##### Example\n\nFor example, to use a 3rd party C library or C systems interface, define the low-level interface in the common subset of C and C++ for better type checking.\nWhenever possible encapsulate the low-level interface in an interface that follows the C++ guidelines (for better abstraction, memory safety, and resource safety) and use that C++ interface in C++ code.\n\n##### Example\n\nYou can call C from C++:\n\n    // in C:\n    double sqrt(double);\n\n    // in C++:\n    extern \"C\" double sqrt(double);\n\n    sqrt(2);\n\n##### Example\n\nYou can call C++ from C:\n\n    // in C:\n    X call_f(struct Y*, int);\n\n    // in C++:\n    extern \"C\" X call_f(Y* p, int i)\n    {\n        return p->f(i);   // possibly a virtual function call\n    }\n\n##### Enforcement\n\nNone needed\n\n# <a name=\"s-source\"></a>SF: Source files\n\nDistinguish between declarations (used as interfaces) and definitions (used as implementations).\nUse header files to represent interfaces and to emphasize logical structure.\n\nSource file rule summary:\n\n* [SF.1: Use a `.cpp` suffix for code files and `.h` for interface files if your project doesn't already follow another convention](#rs-file-suffix)\n* [SF.2: A header file must not contain object definitions or non-inline function definitions](#rs-inline)\n* [SF.3: Use header files for all declarations used in multiple source files](#rs-declaration-header)\n* [SF.4: Include header files before other declarations in a file](#rs-include-order)\n* [SF.5: A `.cpp` file must include the header file(s) that defines its interface](#rs-consistency)\n* [SF.6: Use `using namespace` directives for transition, for foundation libraries (such as `std`), or within a local scope (only)](#rs-using)\n* [SF.7: Don't write `using namespace` at global scope in a header file](#rs-using-directive)\n* [SF.8: Use `#include` guards for all header files](#rs-guards)\n* [SF.9: Avoid cyclic dependencies among source files](#rs-cycles)\n* [SF.10: Avoid dependencies on implicitly `#include`d names](#rs-implicit)\n* [SF.11: Header files should be self-contained](#rs-contained)\n* [SF.12: Prefer the quoted form of `#include` for files relative to the including file and the angle bracket form everywhere else](#rs-incform)\n* [SF.13: Use portable header identifiers in `#include` statements](#rs-portable-header-id)\n\n* [SF.20: Use `namespace`s to express logical structure](#rs-namespace)\n* [SF.21: Don't use an unnamed (anonymous) namespace in a header](#rs-unnamed)\n* [SF.22: Use an unnamed (anonymous) namespace for all internal/non-exported entities](#rs-unnamed2)\n\n### <a name=\"rs-file-suffix\"></a>SF.1: Use a `.cpp` suffix for code files and `.h` for interface files if your project doesn't already follow another convention\n\nSee [NL.27](#rl-file-suffix)\n\n### <a name=\"rs-inline\"></a>SF.2: A header file must not contain object definitions or non-inline function definitions\n\n##### Reason\n\nIncluding entities subject to the one-definition rule leads to linkage errors.\n\n##### Example\n\n    // file.h:\n    namespace Foo {\n        int x = 7;\n        int xx() { return x+x; }\n    }\n\n    // file1.cpp:\n    #include <file.h>\n    // ... more ...\n\n     // file2.cpp:\n    #include <file.h>\n    // ... more ...\n\nLinking `file1.cpp` and `file2.cpp` will give two linker errors.\n\n**Alternative formulation**: A header file must contain only:\n\n* `#include`s of other header files (possibly with include guards)\n* templates\n* class definitions\n* function declarations\n* `extern` declarations\n* `inline` function definitions\n* `constexpr` definitions\n* `const` definitions\n* `using` alias definitions\n* ???\n\n##### Enforcement\n\nCheck the positive list above.\n\n### <a name=\"rs-declaration-header\"></a>SF.3: Use header files for all declarations used in multiple source files\n\n##### Reason\n\nMaintainability. Readability.\n\n##### Example, bad\n\n    // bar.cpp:\n    void bar() { cout << \"bar\\n\"; }\n\n    // foo.cpp:\n    extern void bar();\n    void foo() { bar(); }\n\nA maintainer of `bar` cannot find all declarations of `bar` if its type needs changing.\nThe user of `bar` cannot know if the interface used is complete and correct. At best, error messages come (late) from the linker.\n\n##### Enforcement\n\n* Flag declarations of entities in other source files not placed in a `.h`.\n\n### <a name=\"rs-include-order\"></a>SF.4: Include header files before other declarations in a file\n\n##### Reason\n\nMinimize context dependencies and increase readability.\n\n##### Example\n\n    #include <vector>\n    #include <algorithm>\n    #include <string>\n\n    // ... my code here ...\n\n##### Example, bad\n\n    #include <vector>\n\n    // ... my code here ...\n\n    #include <algorithm>\n    #include <string>\n\n##### Note\n\nThis applies to both `.h` and `.cpp` files.\n\n##### Note\n\nThere is an argument for insulating code from declarations and macros in header files by `#including` headers *after* the code we want to protect\n(as in the example labeled \"bad\").\nHowever\n\n* that only works for one file (at one level): Use that technique in a header included with other headers and the vulnerability reappears.\n* a namespace (an \"implementation namespace\") can protect against many context dependencies.\n* full protection and flexibility require modules.\n\n**See also**:\n\n* [Working Draft, Extensions to C++ for Modules](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4592.pdf)\n* [Modules, Componentization, and Transition](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0141r0.pdf)\n\n##### Enforcement\n\nEasy.\n\n### <a name=\"rs-consistency\"></a>SF.5: A `.cpp` file must include the header file(s) that defines its interface\n\n##### Reason\n\nThis enables the compiler to do an early consistency check.\n\n##### Example, bad\n\n    // foo.h:\n    void foo(int);\n    int bar(long);\n    int foobar(int);\n\n    // foo.cpp:\n    void foo(int) { /* ... */ }\n    int bar(double) { /* ... */ }\n    double foobar(int);\n\nThe errors will not be caught until link time for a program calling `bar` or `foobar`.\n\n##### Example\n\n    // foo.h:\n    void foo(int);\n    int bar(long);\n    int foobar(int);\n\n    // foo.cpp:\n    #include \"foo.h\"\n\n    void foo(int) { /* ... */ }\n    int bar(double) { /* ... */ }\n    double foobar(int);   // error: wrong return type\n\nThe return-type error for `foobar` is now caught immediately when `foo.cpp` is compiled.\nThe argument-type error for `bar` cannot be caught until link time because of the possibility of overloading, but systematic use of `.h` files increases the likelihood that it is caught earlier by the programmer.\n\n##### Enforcement\n\n???\n\n### <a name=\"rs-using\"></a>SF.6: Use `using namespace` directives for transition, for foundation libraries (such as `std`), or within a local scope (only)\n\n##### Reason\n\n `using namespace` can lead to name clashes, so it should be used sparingly.\n However, it is not always possible to qualify every name from a namespace in user code (e.g., during transition)\n and sometimes a namespace is so fundamental and prevalent in a code base, that consistent qualification would be verbose and distracting.\n\n##### Example\n\n    #include <string>\n    #include <vector>\n    #include <iostream>\n    #include <memory>\n    #include <algorithm>\n\n    using namespace std;\n\n    // ...\n\nHere (obviously), the standard library is used pervasively and apparently no other library is used, so requiring `std::` everywhere\ncould be distracting.\n\n##### Example\n\nThe use of `using namespace std;` leaves the programmer open to a name clash with a name from the standard library\n\n    #include <cmath>\n    using namespace std;\n\n    int g(int x)\n    {\n        int sqrt = 7;\n        // ...\n        return sqrt(x); // error\n    }\n\nHowever, this is not particularly likely to lead to a resolution that is not an error and\npeople who use `using namespace std` are supposed to know about `std` and about this risk.\n\n##### Note\n\nA `.cpp` file is a form of local scope.\nThere is little difference in the opportunities for name clashes in an N-line `.cpp` containing a `using namespace X`,\nan N-line function containing a `using namespace X`,\nand M functions each containing a `using namespace X` with N lines of code in total.\n\n##### Note\n\n[Don't write `using namespace` at global scope in a header file](#rs-using-directive).\n\n### <a name=\"rs-using-directive\"></a>SF.7: Don't write `using namespace` at global scope in a header file\n\n##### Reason\n\nDoing so takes away an `#include`r's ability to effectively disambiguate and to use alternatives. It also makes `#include`d headers order-dependent as they might have different meaning when included in different orders.\n\n##### Example\n\n    // bad.h\n    #include <iostream>\n    using namespace std; // bad\n\n    // user.cpp\n    #include \"bad.h\"\n\n    bool copy(/*... some parameters ...*/);    // some function that happens to be named copy\n\n    int main()\n    {\n        copy(/*...*/);    // now overloads local ::copy and std::copy, could be ambiguous\n    }\n\n##### Note\n\nAn exception is `using namespace std::literals;`. This is necessary to use string literals\nin header files and given [the rules](https://eel.is/c++draft/over.literal) - users are required\nto name their own UDLs `operator\"\"_x` - they will not collide with the standard library.\n\n##### Enforcement\n\nFlag `using namespace` at global scope in a header file.\n\n### <a name=\"rs-guards\"></a>SF.8: Use `#include` guards for all header files\n\n##### Reason\n\nTo avoid files being `#include`d several times.\n\nIn order to avoid include guard collisions, do not just name the guard after the filename.\nBe sure to also include a key and good differentiator, such as the name of library or component\nthe header file is part of.\n\n##### Example\n\n    // file foobar.h:\n    #ifndef LIBRARY_FOOBAR_H\n    #define LIBRARY_FOOBAR_H\n    // ... declarations ...\n    #endif // LIBRARY_FOOBAR_H\n\n##### Enforcement\n\nFlag `.h` files without `#include` guards.\n\n##### Note\n\nSome implementations offer vendor extensions like `#pragma once` as alternative to include guards.\nIt is not standard and it is not portable.  It injects the hosting machine's filesystem semantics\ninto your program, in addition to locking you down to a vendor.\nOur recommendation is to write in ISO C++: See [rule P.2](#rp-cplusplus).\n\n### <a name=\"rs-cycles\"></a>SF.9: Avoid cyclic dependencies among source files\n\n##### Reason\n\nCycles complicate comprehension and slow down compilation. They also\ncomplicate conversion to use language-supported modules (when they become\navailable).\n\n##### Note\n\nEliminate cycles; don't just break them with `#include` guards.\n\n##### Example, bad\n\n    // file1.h:\n    #include \"file2.h\"\n\n    // file2.h:\n    #include \"file3.h\"\n\n    // file3.h:\n    #include \"file1.h\"\n\n##### Enforcement\n\nFlag all cycles.\n\n\n### <a name=\"rs-implicit\"></a>SF.10: Avoid dependencies on implicitly `#include`d names\n\n##### Reason\n\nAvoid surprises.\nAvoid having to change `#include`s if an `#include`d header changes.\nAvoid accidentally becoming dependent on implementation details and logically separate entities included in a header.\n\n##### Example, bad\n\n    #include <iostream>\n    using namespace std;\n\n    void use()\n    {\n        string s;\n        cin >> s;               // fine\n        getline(cin, s);        // error: getline() not defined\n        if (s == \"surprise\") {  // error == not defined\n            // ...\n        }\n    }\n\n`<iostream>` exposes the definition of `std::string` (\"why?\" makes for a fun trivia question),\nbut it is not required to do so by transitively including the entire `<string>` header,\nresulting in the popular beginner question \"why doesn't `getline(cin,s);` work?\"\nor even an occasional \"`string`s cannot be compared with `==`\").\n\nThe solution is to explicitly `#include <string>`:\n\n##### Example, good\n\n    #include <iostream>\n    #include <string>\n    using namespace std;\n\n    void use()\n    {\n        string s;\n        cin >> s;               // fine\n        getline(cin, s);        // fine\n        if (s == \"surprise\") {  // fine\n            // ...\n        }\n    }\n\n##### Note\n\nSome headers exist exactly to collect a set of consistent declarations from a variety of headers.\nFor example:\n\n    // basic_std_lib.h:\n\n    #include <string>\n    #include <map>\n    #include <iostream>\n    #include <random>\n    #include <vector>\n\na user can now get that set of declarations with a single `#include`\n\n    #include \"basic_std_lib.h\"\n\nThis rule against implicit inclusion is not meant to prevent such deliberate aggregation.\n\n##### Enforcement\n\nEnforcement would require some knowledge about what in a header is meant to be \"exported\" to users and what is there to enable implementation.\nNo really good solution is possible until we have modules.\n\n### <a name=\"rs-contained\"></a>SF.11: Header files should be self-contained\n\n##### Reason\n\nUsability, headers should be simple to use and work when included on their own.\nHeaders should encapsulate the functionality they provide.\nAvoid clients of a header having to manage that header's dependencies.\n\n##### Example\n\n    #include \"helpers.h\"\n    // helpers.h depends on std::string and includes <string>\n\n##### Note\n\nFailing to follow this results in difficult to diagnose errors for clients of a header.\n\n##### Note\n\nA header should include all its dependencies. Be careful about using relative paths because C++ implementations diverge on their meaning.\n\n##### Enforcement\n\nA test should verify that the header file itself compiles or that a cpp file which only includes the header file compiles.\n\n### <a name=\"rs-incform\"></a>SF.12: Prefer the quoted form of `#include` for files relative to the including file and the angle bracket form everywhere else\n\n##### Reason\n\nThe [standard](https://eel.is/c++draft/cpp.include) provides flexibility for compilers to implement\nthe two forms of `#include` selected using the angle (`<>`) or quoted (`\"\"`) syntax. Vendors take\nadvantage of this and use different search algorithms and methods for specifying the include path.\n\nNevertheless, the guidance is to use the quoted form for including files that exist at a relative path to the file containing the `#include` statement (from within the same component or project) and to use the angle bracket form everywhere else, where possible. This encourages being clear about the locality of the file relative to files that include it, or scenarios where the different search algorithm is required. It makes it easy to understand at a glance whether a header is being included from a local relative file versus a standard library header or a header from the alternate search path (e.g. a header from another library or a common set of includes).\n\n##### Example\n\n    // foo.cpp:\n    #include <string>                // From the standard library, requires the <> form\n    #include <some_library/common.h> // A file that is not locally relative, included from another library; use the <> form\n    #include \"foo.h\"                 // A file locally relative to foo.cpp in the same project, use the \"\" form\n    #include \"util/util.h\"           // A file locally relative to foo.cpp in the same project, use the \"\" form\n    #include <component_b/bar.h>     // A file in the same project located via a search path, use the <> form\n\n##### Note\n\nFailing to follow this results in difficult to diagnose errors due to picking up the wrong file by incorrectly specifying the scope when it is included. For example, in a typical case where the `#include \"\"` search algorithm might search for a file existing at a local relative path first, then using this form to refer to a file that is not locally relative could mean that if a file ever comes into existence at the local relative path (e.g. the including file is moved to a new location), it will now be found ahead of the previous include file and the set of includes will have been changed in an unexpected way.\n\nLibrary creators should put their headers in a folder and have clients include those files using the relative path `#include <some_library/common.h>`\n\n##### Enforcement\n\nA test should identify whether headers referenced via `\"\"` could be referenced with `<>`.\n\n### <a name=\"rs-portable-header-id\"></a>SF.13: Use portable header identifiers in `#include` statements\n\n##### Reason\n\nThe [standard](https://eel.is/c++draft/cpp.include) does not specify how compilers uniquely locate headers from an identifier in an `#include` directive, nor does it specify what constitutes uniqueness. For example, whether the implementation considers the identifiers to be case-sensitive, or whether the identifiers are file system paths to a header file, and if so, how a hierarchical file system path is delimited.\n\nTo maximize the portability of `#include` directives across compilers, guidance is to:\n\n* use case-sensitivity for the header identifier, matching how the header is defined by the standard, specification, implementation, or file that provides the header.\n* when the header identifier is a hierarchical file path, use forward-slash `/` to delimit path components as this is the most widely-accepted path-delimiting character.\n\n##### Example\n\n    // good examples\n    #include <vector>\n    #include <string>\n    #include \"util/util.h\"\n\n    // bad examples\n    #include <VECTOR>        // bad: the standard library defines a header identified as <vector>, not <VECTOR>\n    #include <String>        // bad: the standard library defines a header identified as <string>, not <String>\n    #include \"Util/Util.H\"   // bad: the header file exists on the file system as \"util/util.h\"\n    #include \"util\\util.h\"   // bad: may not work if the implementation interprets `\\u` as an escape sequence, or where '\\' is not a valid path separator\n\n##### Enforcement\n\nIt is only possible to enforce on implementations where header identifiers are case-sensitive and which only support `/` as a file path delimiter.\n\n### <a name=\"rs-namespace\"></a>SF.20: Use `namespace`s to express logical structure\n\n##### Reason\n\n ???\n\n##### Example\n\n    ???\n\n##### Enforcement\n\n???\n\n### <a name=\"rs-unnamed\"></a>SF.21: Don't use an unnamed (anonymous) namespace in a header\n\n##### Reason\n\nIt is almost always a bug to mention an unnamed namespace in a header file.\n\n##### Example\n\n    // file foo.h:\n    namespace\n    {\n        const double x = 1.234;  // bad\n\n        double foo(double y)     // bad\n        {\n            return y + x;\n        }\n    }\n\n    namespace Foo\n    {\n        const double x = 1.234; // good\n\n        inline double foo(double y)        // good\n        {\n            return y + x;\n        }\n    }\n\n##### Enforcement\n\n* Flag any use of an anonymous namespace in a header file.\n\n### <a name=\"rs-unnamed2\"></a>SF.22: Use an unnamed (anonymous) namespace for all internal/non-exported entities\n\n##### Reason\n\nNothing external can depend on an entity in a nested unnamed namespace.\nConsider putting every definition in an implementation source file in an unnamed namespace unless that is defining an \"external/exported\" entity.\n\n##### Example; bad\n\n    static int f();\n    int g();\n    static bool h();\n    int k();\n\n##### Example; good\n\n    namespace {\n        int f();\n        bool h();\n    }\n    int g();\n    int k();\n\n##### Example\n\nAn API class and its members can't live in an unnamed namespace; but any \"helper\" class or function that is defined in an implementation source file should be at an unnamed namespace scope.\n\n    ???\n\n##### Enforcement\n\n* ???\n\n# <a name=\"s-stdlib\"></a>SL: The Standard Library\n\nUsing only the bare language, every task is tedious (in any language).\nUsing a suitable library any task can be reasonably simple.\n\nThe standard library has steadily grown over the years.\nIts description in the standard is now larger than that of the language features.\nSo, it is likely that this library section of the guidelines will eventually grow in size to equal or exceed all the rest.\n\n<< ??? We need another level of rule numbering ??? >>\n\nC++ Standard Library component summary:\n\n* [SL.con: Containers](#ss-con)\n* [SL.str: String](#ss-string)\n* [SL.io: Iostream](#ss-io)\n* [SL.regex: Regex](#ss-regex)\n* [SL.chrono: Time](#ss-chrono)\n* [SL.C: The C Standard Library](#ss-clib)\n\nStandard-library rule summary:\n\n* [SL.1: Use libraries wherever possible](#rsl-lib)\n* [SL.2: Prefer the standard library to other libraries](#rsl-sl)\n* [SL.3: Do not add non-standard entities to namespace `std`](#sl-std)\n* [SL.4: Use the standard library in a type-safe manner](#sl-safe)\n* ???\n\n### <a name=\"rsl-lib\"></a>SL.1:  Use libraries wherever possible\n\n##### Reason\n\nSave time. Don't re-invent the wheel.\nDon't replicate the work of others.\nBenefit from other people's work when they make improvements.\nHelp other people when you make improvements.\n\n### <a name=\"rsl-sl\"></a>SL.2: Prefer the standard library to other libraries\n\n##### Reason\n\nMore people know the standard library.\nIt is more likely to be stable, well-maintained, and widely available than your own code or most other libraries.\n\n\n### <a name=\"sl-std\"></a>SL.3: Do not add non-standard entities to namespace `std`\n\n##### Reason\n\nAdding to `std` might change the meaning of otherwise standards conforming code.\nAdditions to `std` might clash with future versions of the standard.\n\n##### Example\n\n    namespace std { // BAD: violates standard\n\n    class My_vector {\n        //     . . .\n    };\n\n    }\n\n    namespace Foo { // GOOD: user namespace is allowed\n\n    class My_vector {\n        //     . . .\n    };\n\n    }\n\n##### Enforcement\n\nPossible, but messy and likely to cause problems with platforms.\n\n### <a name=\"sl-safe\"></a>SL.4: Use the standard library in a type-safe manner\n\n##### Reason\n\nBecause, obviously, breaking this rule can lead to undefined behavior, memory corruption, and all kinds of other bad errors.\n\n##### Note\n\nThis is a semi-philosophical meta-rule, which needs many supporting concrete rules.\nWe need it as an umbrella for the more specific rules.\n\nSummary of more specific rules:\n\n* [SL.4: Use the standard library in a type-safe manner](#sl-safe)\n\n\n## <a name=\"ss-con\"></a>SL.con: Containers\n\n???\n\nContainer rule summary:\n\n* [SL.con.1: Prefer using STL `array` or `vector` instead of a C array](#rsl-arrays)\n* [SL.con.2: Prefer using STL `vector` by default unless you have a reason to use a different container](#rsl-vector)\n* [SL.con.3: Avoid bounds errors](#rsl-bounds)\n* [SL.con.4: don't use `memset` or `memcpy` for arguments that are not trivially-copyable](#rsl-copy)\n\n### <a name=\"rsl-arrays\"></a>SL.con.1: Prefer using STL `array` or `vector` instead of a C array\n\n##### Reason\n\nC arrays are less safe, and have no advantages over `array` and `vector`.\nFor a fixed-length array, use `std::array`, which does not degenerate to a pointer when passed to a function and does know its size.\nAlso, like a built-in array, a stack-allocated `std::array` keeps its elements on the stack.\nFor a variable-length array, use `std::vector`, which additionally can change its size and handles memory allocation.\n\n##### Example\n\n    int v[SIZE];                        // BAD\n\n    std::array<int, SIZE> w;            // ok\n\n##### Example\n\n    int* v = new int[initial_size];     // BAD, owning raw pointer\n    delete[] v;                         // BAD, manual delete\n\n    std::vector<int> w(initial_size);   // ok\n\n##### Note\n\nUse `gsl::span` for non-owning references into a container.\n\n##### Note\n\nComparing the performance of a fixed-sized array allocated on the stack against a `vector` with its elements on the free store is bogus.\nYou could just as well compare a `std::array` on the stack against the result of a `malloc()` accessed through a pointer.\nFor most code, even the difference between stack allocation and free-store allocation doesn't matter, but the convenience and safety of `vector` does.\nPeople working with code for which that difference matters are quite capable of choosing between `array` and `vector`.\n\n##### Enforcement\n\n* Flag declaration of a C array inside a function or class that also declares an STL container (to avoid excessive noisy warnings on legacy non-STL code). To fix: At least change the C array to a `std::array`.\n\n### <a name=\"rsl-vector\"></a>SL.con.2: Prefer using STL `vector` by default unless you have a reason to use a different container\n\n##### Reason\n\n`vector` and `array` are the only standard containers that offer the following advantages:\n\n* the fastest general-purpose access (random access, including being vectorization-friendly);\n* the fastest default access pattern (begin-to-end or end-to-begin is prefetcher-friendly);\n* the lowest space overhead (contiguous layout has zero per-element overhead, which is cache-friendly).\n\nUsually you need to add and remove elements from the container, so use `vector` by default; if you don't need to modify the container's size, use `array`.\n\nEven when other containers seem more suited, such as `map` for O(log N) lookup performance or a `list` for efficient insertion in the middle, a `vector` will usually still perform better for containers up to a few KB in size.\n\n##### Note\n\n`string` should not be used as a container of individual characters. A `string` is a textual string; if you want a container of characters, use `vector</*char_type*/>` or `array</*char_type*/>` instead.\n\n##### Exceptions\n\nIf you have a good reason to use another container, use that instead. For example:\n\n* If `vector` suits your needs but you don't need the container to be variable size, use `array` instead.\n\n* If you want a dictionary-style lookup container that guarantees O(K) or O(log N) lookups, the container will be larger (more than a few KB) and you perform frequent inserts so that the overhead of maintaining a sorted `vector` is infeasible, go ahead and use an `unordered_map` or `map` instead.\n\n##### Note\n\nTo initialize a vector with a number of elements, use `()`-initialization.\nTo initialize a vector with a list of elements, use `{}`-initialization.\n\n    vector<int> v1(20);  // v1 has 20 elements with the value 0 (vector<int>{})\n    vector<int> v2 {20}; // v2 has 1 element with the value 20\n\n[Prefer the {}-initializer syntax](#res-list).\n\n##### Enforcement\n\n* Flag a `vector` whose size never changes after construction (such as because it's `const` or because no non-`const` functions are called on it). To fix: Use an `array` instead.\n\n### <a name=\"rsl-bounds\"></a>SL.con.3: Avoid bounds errors\n\n##### Reason\n\nRead or write beyond an allocated range of elements typically leads to bad errors, wrong results, crashes, and security violations.\n\n##### Note\n\nThe standard-library functions that apply to ranges of elements all have (or could have) bounds-safe overloads that take `span`.\nStandard types such as `vector` can be modified to perform bounds-checks under the bounds profile (in a compatible way, such as by adding contracts), or used with `at()`.\n\nIdeally, the in-bounds guarantee should be statically enforced.\nFor example:\n\n* a range-`for` cannot loop beyond the range of the container to which it is applied\n* a `v.begin(),v.end()` is easily determined to be bounds safe\n\nSuch loops are as fast as any unchecked/unsafe equivalent.\n\nOften a simple pre-check can eliminate the need for checking of individual indices.\nFor example\n\n* for `v.begin(),v.begin()+i` the `i` can easily be checked against `v.size()`\n\nSuch loops can be much faster than individually checked element accesses.\n\n##### Example, bad\n\n    void f()\n    {\n        array<int, 10> a, b;\n        memset(a.data(), 0, 10);         // BAD, and contains a length error (length = 10 * sizeof(int))\n        memcmp(a.data(), b.data(), 10);  // BAD, and contains a length error (length = 10 * sizeof(int))\n    }\n\nAlso, `std::array<>::fill()` or `std::fill()` or even an empty initializer are better candidates than `memset()`.\n\n##### Example, good\n\n    void f()\n    {\n        array<int, 10> a, b, c{};       // c is initialized to zero\n        a.fill(0);\n        fill(b.begin(), b.end(), 0);    // std::fill()\n        fill(b, 0);                     // std::ranges::fill()\n\n        if ( a == b ) {\n          // ...\n        }\n    }\n\n##### Example\n\nIf code is using an unmodified standard library, then there are still workarounds that enable use of `std::array` and `std::vector` in a bounds-safe manner. Code can call the `.at()` member function on each class, which will result in an `std::out_of_range` exception being thrown. Alternatively, code can call the `at()` free function, which will result in fail-fast (or a customized action) on a bounds violation.\n\n    void f(std::vector<int>& v, std::array<int, 12> a, int i)\n    {\n        v[0] = a[0];        // BAD\n        v.at(0) = a[0];     // OK (alternative 1)\n        at(v, 0) = a[0];    // OK (alternative 2)\n\n        v.at(0) = a[i];     // BAD\n        v.at(0) = a.at(i);  // OK (alternative 1)\n        v.at(0) = at(a, i); // OK (alternative 2)\n    }\n\n##### Enforcement\n\n* Issue a diagnostic for any call to a standard-library function that is not bounds-checked.\n??? insert link to a list of banned functions\n\nThis rule is part of the [bounds profile](#ss-bounds).\n\n\n### <a name=\"rsl-copy\"></a>SL.con.4: don't use `memset` or `memcpy` for arguments that are not trivially-copyable\n\n##### Reason\n\nDoing so messes the semantics of the objects (e.g., by overwriting a `vptr`).\n\n##### Note\n\nSimilarly for (w)memset, (w)memcpy, (w)memmove, and (w)memcmp\n\n##### Example\n\n    struct base {\n        virtual void update() = 0;\n    };\n\n    struct derived : public base {\n        void update() override {}\n    };\n\n\n    void f(derived& a, derived& b) // goodbye v-tables\n    {\n        memset(&a, 0, sizeof(derived));\n        memcpy(&a, &b, sizeof(derived));\n        memcmp(&a, &b, sizeof(derived));\n    }\n\nInstead, define proper default initialization, copy, and comparison functions\n\n    void g(derived& a, derived& b)\n    {\n        a = {};    // default initialize\n        b = a;     // copy\n        if (a == b) do_something(a, b);\n    }\n\n##### Enforcement\n\n* Flag the use of those functions for types that are not trivially copyable\n\n**TODO Notes**:\n\n* Impact on the standard library will require close coordination with WG21, if only to ensure compatibility even if never standardized.\n* We are considering specifying bounds-safe overloads for stdlib (especially C stdlib) functions like `memcmp` and shipping them in the GSL.\n* For existing stdlib functions and types like `vector` that are not fully bounds-checked, the goal is for these features to be bounds-checked when called from code with the bounds profile on, and unchecked when called from legacy code, possibly using contracts (concurrently being proposed by several WG21 members).\n\n\n\n## <a name=\"ss-string\"></a>SL.str: String\n\nText manipulation is a huge topic.\n`std::string` doesn't cover all of it.\nThis section primarily tries to clarify `std::string`'s relation to `char*`, `zstring`, `string_view`, and `gsl::span<char>`.\nThe important issue of non-ASCII character sets and encodings (e.g., `wchar_t`, Unicode, and UTF-8) will be covered elsewhere.\n\n**See also**: [regular expressions](#ss-regex)\n\nHere, we use \"sequence of characters\" or \"string\" to refer to a sequence of characters meant to be read as text (somehow, eventually).\nWe don't consider ???\n\nString summary:\n\n* [SL.str.1: Use `std::string` to own character sequences](#rstr-string)\n* [SL.str.2: Use `std::string_view` or `gsl::span<char>` to refer to character sequences](#rstr-view)\n* [SL.str.3: Use `zstring` or `czstring` to refer to a C-style, zero-terminated, sequence of characters](#rstr-zstring)\n* [SL.str.4: Use `char*` to refer to a single character](#rstr-charp)\n* [SL.str.5: Use `std::byte` to refer to byte values that do not necessarily represent characters](#rstr-byte)\n\n* [SL.str.10: Use `std::string` when you need to perform locale-sensitive string operations](#rstr-locale)\n* [SL.str.11: Use `gsl::span<char>` rather than `std::string_view` when you need to mutate a string](#rstr-span)\n* [SL.str.12: Use the `s` suffix for string literals meant to be standard-library `string`s](#rstr-s)\n\n**See also**:\n\n* [F.24 span](#rf-range)\n* [F.25 zstring](#rf-zstring)\n\n\n### <a name=\"rstr-string\"></a>SL.str.1: Use `std::string` to own character sequences\n\n##### Reason\n\n`string` correctly handles allocation, ownership, copying, gradual expansion, and offers a variety of useful operations.\n\n##### Example\n\n    vector<string> read_until(const string& terminator)\n    {\n        vector<string> res;\n        for (string s; cin >> s && s != terminator; ) // read a word\n            res.push_back(s);\n        return res;\n    }\n\nNote how `>>` and `!=` are provided for `string` (as examples of useful operations) and there are no explicit\nallocations, deallocations, or range checks (`string` takes care of those).\n\nIn C++17, we might use `string_view` as the argument, rather than `const string&` to allow more flexibility to callers:\n\n    vector<string> read_until(string_view terminator)   // C++17\n    {\n        vector<string> res;\n        for (string s; cin >> s && s != terminator; ) // read a word\n            res.push_back(s);\n        return res;\n    }\n\n##### Example, bad\n\nDon't use C-style strings for operations that require non-trivial memory management\n\n    char* cat(const char* s1, const char* s2)   // beware!\n        // return s1 + '.' + s2\n    {\n        int l1 = strlen(s1);\n        int l2 = strlen(s2);\n        char* p = (char*) malloc(l1 + l2 + 2);\n        strcpy(p, s1, l1);\n        p[l1] = '.';\n        strcpy(p + l1 + 1, s2, l2);\n        p[l1 + l2 + 1] = 0;\n        return p;\n    }\n\nDid we get that right?\nWill the caller remember to `free()` the returned pointer?\nWill this code pass a security review?\n\n##### Note\n\nDo not assume that `string` is slower than lower-level techniques without measurement and remember that not all code is performance critical.\n[Don't optimize prematurely](#rper-knuth)\n\n##### Enforcement\n\n???\n\n### <a name=\"rstr-view\"></a>SL.str.2: Use `std::string_view` or `gsl::span<char>` to refer to character sequences\n\n##### Reason\n\n`std::string_view` or `gsl::span<char>` provides simple and (potentially) safe access to character sequences independently of how\nthose sequences are allocated and stored.\n\n##### Example\n\n    vector<string> read_until(string_view terminator);\n\n    void user(zstring p, const string& s, string_view ss)\n    {\n        auto v1 = read_until(p);\n        auto v2 = read_until(s);\n        auto v3 = read_until(ss);\n        // ...\n    }\n\n##### Note\n\n`std::string_view` (C++17) is read-only.\n\n##### Enforcement\n\n???\n\n### <a name=\"rstr-zstring\"></a>SL.str.3: Use `zstring` or `czstring` to refer to a C-style, zero-terminated, sequence of characters\n\n##### Reason\n\nReadability.\nStatement of intent.\nA plain `char*` can be a pointer to a single character, a pointer to an array of characters, a pointer to a C-style (zero-terminated) string, or even to a small integer.\nDistinguishing these alternatives prevents misunderstandings and bugs.\n\n##### Example\n\n    void f1(const char* s); // s is probably a string\n\nAll we know is that it is supposed to be the nullptr or point to at least one character\n\n    void f1(zstring s);     // s is a C-style string or the nullptr\n    void f1(czstring s);    // s is a C-style string constant or the nullptr\n    void f1(std::byte* s);  // s is a pointer to a byte (C++17)\n\n##### Note\n\nDon't convert a C-style string to `string` unless there is a reason to.\n\n##### Note\n\nLike any other \"plain pointer\", a `zstring` should not represent ownership.\n\n##### Note\n\nThere are billions of lines of C++ \"out there\", most use `char*` and `const char*` without documenting intent.\nThey are used in a wide variety of ways, including to represent ownership and as generic pointers to memory (instead of `void*`).\nIt is hard to separate these uses, so this guideline is hard to follow.\nThis is one of the major sources of bugs in C and C++ programs, so it is worthwhile to follow this guideline wherever feasible.\n\n##### Enforcement\n\n* Flag uses of `[]` on a `char*`\n* Flag uses of `delete` on a `char*`\n* Flag uses of `free()` on a `char*`\n\n### <a name=\"rstr-charp\"></a>SL.str.4: Use `char*` to refer to a single character\n\n##### Reason\n\nThe variety of uses of `char*` in current code is a major source of errors.\n\n##### Example, bad\n\n    char arr[] = {'a', 'b', 'c'};\n\n    void print(const char* p)\n    {\n        cout << p << '\\n';\n    }\n\n    void use()\n    {\n        print(arr);   // run-time error; potentially very bad\n    }\n\nThe array `arr` is not a C-style string because it is not zero-terminated.\n\n##### Alternative\n\nSee [`zstring`](#rstr-zstring), [`string`](#rstr-string), and [`string_view`](#rstr-view).\n\n##### Enforcement\n\n* Flag uses of `[]` on a `char*`\n\n### <a name=\"rstr-byte\"></a>SL.str.5: Use `std::byte` to refer to byte values that do not necessarily represent characters\n\n##### Reason\n\nUse of `char*` to represent a pointer to something that is not necessarily a character causes confusion\nand disables valuable optimizations.\n\n##### Example\n\n    ???\n\n##### Note\n\nC++17\n\n##### Enforcement\n\n???\n\n\n### <a name=\"rstr-locale\"></a>SL.str.10: Use `std::string` when you need to perform locale-sensitive string operations\n\n##### Reason\n\n`std::string` supports standard-library [`locale` facilities](#rstr-locale)\n\n##### Example\n\n    ???\n\n##### Note\n\n???\n\n##### Enforcement\n\n???\n\n### <a name=\"rstr-span\"></a>SL.str.11: Use `gsl::span<char>` rather than `std::string_view` when you need to mutate a string\n\n##### Reason\n\n`std::string_view` is read-only.\n\n##### Example\n\n???\n\n##### Note\n\n???\n\n##### Enforcement\n\nThe compiler will flag attempts to write to a `string_view`.\n\n### <a name=\"rstr-s\"></a>SL.str.12: Use the `s` suffix for string literals meant to be standard-library `string`s\n\n##### Reason\n\nDirect expression of an idea minimizes mistakes.\n\n##### Example\n\n    auto pp1 = make_pair(\"Tokyo\", 9.00);         // {C-style string,double} intended?\n    pair<string, double> pp2 = {\"Tokyo\", 9.00};  // a bit verbose\n    auto pp3 = make_pair(\"Tokyo\"s, 9.00);        // {std::string,double}    // C++14\n    pair pp4 = {\"Tokyo\"s, 9.00};                 // {std::string,double}    // C++17\n\n\n\n##### Enforcement\n\n???\n\n\n## <a name=\"ss-io\"></a>SL.io: Iostream\n\n`iostream`s is a type safe, extensible, formatted and unformatted I/O library for streaming I/O.\nIt supports multiple (and user extensible) buffering strategies and multiple locales.\nIt can be used for conventional I/O, reading and writing to memory (string streams),\nand user-defined extensions, such as streaming across networks (asio: not yet standardized).\n\nIostream rule summary:\n\n* [SL.io.1: Use character-level input only when you have to](#rio-low)\n* [SL.io.2: When reading, always consider ill-formed input](#rio-validate)\n* [SL.io.3: Prefer iostreams for I/O](#rio-streams)\n* [SL.io.10: Unless you use `printf`-family functions call `ios_base::sync_with_stdio(false)`](#rio-sync)\n* [SL.io.50: Avoid `endl`](#rio-endl)\n* [???](#???)\n\n### <a name=\"rio-low\"></a>SL.io.1: Use character-level input only when you have to\n\n##### Reason\n\nUnless you genuinely just deal with individual characters, using character-level input leads to the user code performing potentially error-prone\nand potentially inefficient composition of tokens out of characters.\n\n##### Example\n\n    char c;\n    char buf[128];\n    int i = 0;\n    while (cin.get(c) && !isspace(c) && i < 128)\n        buf[i++] = c;\n    if (i == 128) {\n        // ... handle too long string ....\n    }\n\nBetter (much simpler and probably faster):\n\n    string s;\n    s.reserve(128);\n    cin >> s;\n\nand the `reserve(128)` is probably not worthwhile.\n\n##### Enforcement\n\n???\n\n\n### <a name=\"rio-validate\"></a>SL.io.2: When reading, always consider ill-formed input\n\n##### Reason\n\nErrors are typically best handled as soon as possible.\nIf input isn't validated, every function must be written to cope with bad data (and that is not practical).\n\n##### Example\n\n    ???\n\n##### Enforcement\n\n???\n\n### <a name=\"rio-streams\"></a>SL.io.3: Prefer `iostream`s for I/O\n\n##### Reason\n\n`iostream`s are safe, flexible, and extensible.\n\n##### Example\n\n    // write a complex number:\n    complex<double> z{ 3, 4 };\n    cout << z << '\\n';\n\n`complex` is a user-defined type and its I/O is defined without modifying the `iostream` library.\n\n##### Example\n\n    // read a file of complex numbers:\n    for (complex<double> z; cin >> z; )\n        v.push_back(z);\n\n##### Exception\n\n??? performance ???\n\n##### Discussion: `iostream`s vs. the `printf()` family\n\nIt is often (and often correctly) pointed out that the `printf()` family has two advantages compared to `iostream`s:\nflexibility of formatting and performance.\nThis has to be weighed against `iostream`s advantages of extensibility to handle user-defined types, resilience against security violations,\nimplicit memory management, and `locale` handling.\n\nIf you need I/O performance, you can almost always do better than `printf()`.\n\n`gets()`, `scanf()` using `%s`, and `printf()` using `%s` are security hazards (vulnerable to buffer overflow and generally error-prone).\nC11 defines some \"optional extensions\" that do extra checking of their arguments.\nIf present in your C library, `gets_s()`, `scanf_s()`, and `printf_s()` might be safer alternatives, but they are still not type safe.\n\n##### Enforcement\n\nOptionally flag `<cstdio>` and `<stdio.h>`.\n\n### <a name=\"rio-sync\"></a>SL.io.10: Unless you use `printf`-family functions call `ios_base::sync_with_stdio(false)`\n\n##### Reason\n\nSynchronizing `iostreams` with `printf-style` I/O can be costly.\n`cin` and `cout` are by default synchronized with `printf`.\n\n##### Example\n\n    int main()\n    {\n        ios_base::sync_with_stdio(false);\n        // ... use iostreams ...\n    }\n\n##### Enforcement\n\n???\n\n### <a name=\"rio-endl\"></a>SL.io.50: Avoid `endl`\n\n##### Reason\n\nThe `endl` manipulator is mostly equivalent to `'\\n'` and `\"\\n\"`;\nas most commonly used it simply slows down output by doing redundant `flush()`s.\nThis slowdown can be significant compared to `printf`-style output.\n\n##### Example\n\n    cout << \"Hello, World!\" << endl;    // two output operations and a flush\n    cout << \"Hello, World!\\n\";          // one output operation and no flush\n\n##### Note\n\nFor `cin`/`cout` (and equivalent) interaction, there is no reason to flush; that's done automatically.\nFor writing to a file, there is rarely a need to `flush`.\n\n##### Note\n\nFor string streams (specifically `ostringstream`), the insertion of an `endl` is entirely equivalent\nto the insertion of a `'\\n'` character, but also in this case, `endl` might be significantly slower.\n\n`endl` does *not* take care of producing a platform specific end-of-line sequence (like `\"\\r\\n\"` on\nWindows). So for a string stream, `s << endl` just inserts a *single* character, `'\\n'`.\n\n##### Note\n\nApart from the (occasionally important) issue of performance,\nthe choice between `'\\n'` and `endl` is almost completely aesthetic.\n\n## <a name=\"ss-regex\"></a>SL.regex: Regex\n\n`<regex>` is the standard C++ regular expression library.\nIt supports a variety of regular expression pattern conventions.\n\n## <a name=\"ss-chrono\"></a>SL.chrono: Time\n\n`<chrono>` (defined in namespace `std::chrono`) provides the notions of `time_point` and `duration` together with functions for\noutputting time in various units.\nIt provides clocks for registering `time_points`.\n\n## <a name=\"ss-clib\"></a>SL.C: The C Standard Library\n\n???\n\nC Standard Library rule summary:\n\n* [SL.C.1: Don't use setjmp/longjmp](#rclib-jmp)\n* [???](#???)\n* [???](#???)\n\n### <a name=\"rclib-jmp\"></a>SL.C.1: Don't use setjmp/longjmp\n\n##### Reason\n\na `longjmp` ignores destructors, thus invalidating all resource-management strategies relying on RAII\n\n##### Enforcement\n\nFlag all occurrences of `longjmp`and `setjmp`\n\n\n\n# <a name=\"s-a\"></a>A: Architectural ideas\n\nThis section contains ideas about higher-level architectural ideas and libraries.\n\nArchitectural rule summary:\n\n* [A.1: Separate stable code from less stable code](#ra-stable)\n* [A.2: Express potentially reusable parts as a library](#ra-lib)\n* [A.4: There should be no cycles among libraries](#ra-dag)\n* [???](#???)\n* [???](#???)\n* [???](#???)\n* [???](#???)\n* [???](#???)\n* [???](#???)\n\n### <a name=\"ra-stable\"></a>A.1: Separate stable code from less stable code\n\nIsolating less stable code facilitates its unit testing, interface improvement, refactoring, and eventual deprecation.\n\n### <a name=\"ra-lib\"></a>A.2: Express potentially reusable parts as a library\n\n##### Reason\n\n##### Note\n\nA library is a collection of declarations and definitions maintained, documented, and shipped together.\nA library could be a set of headers (a \"header-only library\") or a set of headers plus a set of object files.\nYou can statically or dynamically link a library into a program, or you can `#include` a header-only library.\n\n\n### <a name=\"ra-dag\"></a>A.4: There should be no cycles among libraries\n\n##### Reason\n\n* A cycle complicates the build process.\n* Cycles are hard to understand and might introduce indeterminism (unspecified behavior).\n\n##### Note\n\nA library can contain cyclic references in the definition of its components.\nFor example:\n\n    ???\n\nHowever, a library should not depend on another that depends on it.\n\n\n# <a name=\"s-not\"></a>NR: Non-Rules and myths\n\nThis section contains rules and guidelines that are popular somewhere, but that we deliberately don't recommend.\nWe know perfectly well that there have been times and places where these rules made sense, and we have used them ourselves at times.\nHowever, in the context of the styles of programming we recommend and support with the guidelines, these \"non-rules\" would do harm.\n\nEven today, there can be contexts where the rules make sense.\nFor example, lack of suitable tool support can make exceptions unsuitable in hard-real-time systems,\nbut please don't naïvely trust \"common wisdom\" (e.g., unsupported statements about \"efficiency\");\nsuch \"wisdom\" might be based on decades-old information or experiences from languages with very different properties than C++\n(e.g., C or Java).\n\nThe positive arguments for alternatives to these non-rules are listed in the rules offered as \"Alternatives\".\n\nNon-rule summary:\n\n* [NR.1: Don't insist that all declarations should be at the top of a function](#rnr-top)\n* [NR.2: Don't insist on having only a single `return`-statement in a function](#rnr-single-return)\n* [NR.3: Don't avoid exceptions](#rnr-no-exceptions)\n* [NR.4: Don't insist on placing each class definition in its own source file](#rnr-lots-of-files)\n* [NR.5: Don't use two-phase initialization](#rnr-two-phase-init)\n* [NR.6: Don't place all cleanup actions at the end of a function and `goto exit`](#rnr-goto-exit)\n* [NR.7: Don't make data members `protected`](#rnr-protected-data)\n* ???\n\n### <a name=\"rnr-top\"></a>NR.1: Don't insist that all declarations should be at the top of a function\n\n##### Reason\n\nThe \"all declarations on top\" rule is a legacy of old programming languages that didn't allow initialization of variables and constants after a statement.\nThis leads to longer programs and more errors caused by uninitialized and wrongly initialized variables.\n\n##### Example, bad\n\n    int use(int x)\n    {\n        int i;\n        char c;\n        double d;\n\n        // ... some stuff ...\n\n        if (x < i) {\n            // ...\n            i = f(x, d);\n        }\n        if (i < x) {\n            // ...\n            i = g(x, c);\n        }\n        return i;\n    }\n\nThe larger the distance between the uninitialized variable and its use, the larger the chance of a bug.\nFortunately, compilers catch many \"used before set\" errors.\nUnfortunately, compilers cannot catch all such errors and unfortunately, the bugs aren't always as simple to spot as in this small example.\n\n\n##### Alternative\n\n* [Always initialize an object](#res-always)\n* [ES.21: Don't introduce a variable (or constant) before you need to use it](#res-introduce)\n\n### <a name=\"rnr-single-return\"></a>NR.2: Don't insist on having only a single `return`-statement in a function\n\n##### Reason\n\nThe single-return rule can lead to unnecessarily convoluted code and the introduction of extra state variables.\nIn particular, the single-return rule makes it harder to concentrate error checking at the top of a function.\n\n##### Example\n\n    template<class T>\n    //  requires Number<T>\n    string sign(T x)\n    {\n        if (x < 0)\n            return \"negative\";\n        if (x > 0)\n            return \"positive\";\n        return \"zero\";\n    }\n\nto use a single return only we would have to do something like\n\n    template<class T>\n    //  requires Number<T>\n    string sign(T x)        // bad\n    {\n        string res;\n        if (x < 0)\n            res = \"negative\";\n        else if (x > 0)\n            res = \"positive\";\n        else\n            res = \"zero\";\n        return res;\n    }\n\nThis is both longer and likely to be less efficient.\nThe larger and more complicated the function is, the more painful the workarounds get.\nOf course many simple functions will naturally have just one `return` because of their simpler inherent logic.\n\n##### Example\n\n    int index(const char* p)\n    {\n        if (!p) return -1;  // error indicator: alternatively \"throw nullptr_error{}\"\n        // ... do a lookup to find the index for p\n        return i;\n    }\n\nIf we applied the rule, we'd get something like\n\n    int index2(const char* p)\n    {\n        int i;\n        if (!p)\n            i = -1;  // error indicator\n        else {\n            // ... do a lookup to find the index for p\n        }\n        return i;\n    }\n\nNote that we (deliberately) violated the rule against uninitialized variables because this style commonly leads to that.\nAlso, this style is a temptation to use the [goto exit](#rnr-goto-exit) non-rule.\n\n##### Alternative\n\n* Keep functions short and simple\n* Feel free to use multiple `return` statements (and to throw exceptions).\n\n### <a name=\"rnr-no-exceptions\"></a>NR.3: Don't avoid exceptions\n\n##### Reason\n\nThere seem to be four main reasons given for not using exceptions:\n\n* exceptions are inefficient\n* exceptions lead to leaks and errors\n* exception performance is not predictable\n* the exception-handling run-time support takes up too much space\n\nThere is no way we can settle this issue to the satisfaction of everybody.\nAfter all, the discussions about exceptions have been going on for 40+ years.\nSome languages cannot be used without exceptions, but others do not support them.\nThis leads to strong traditions for the use and non-use of exceptions, and to heated debates.\n\nHowever, we can briefly outline why we consider exceptions the best alternative for general-purpose programming\nand in the context of these guidelines.\nSimple arguments for and against are often inconclusive.\nThere are specialized applications where exceptions indeed can be inappropriate\n(e.g., hard-real-time systems without support for reliable estimates of the cost of handling an exception).\n\nConsider the major objections to exceptions in turn\n\n* Exceptions are inefficient:\nCompared to what?\nWhen comparing make sure that the same set of errors are handled and that they are handled equivalently.\nIn particular, do not compare a program that immediately terminates on seeing an error to a program\nthat carefully cleans up resources before logging an error.\nYes, some systems have poor exception handling implementations; sometimes, such implementations force us to use\nother error-handling approaches, but that's not a fundamental problem with exceptions.\nWhen using an efficiency argument - in any context - be careful that you have good data that actually provides\ninsight into the problem under discussion.\n* Exceptions lead to leaks and errors.\nThey do not.\nIf your program is a rat's nest of pointers without an overall strategy for resource management,\nyou have a problem whatever you do.\nIf your system consists of a million lines of such code,\nyou probably will not be able to use exceptions,\nbut that's a problem with excessive and undisciplined pointer use, rather than with exceptions.\nIn our opinion, you need RAII to make exception-based error handling simple and safe -- simpler and safer than alternatives.\n* Exception performance is not predictable.\nIf you are in a hard-real-time system where you must guarantee completion of a task in a given time,\nyou need tools to back up such guarantees.\nAs far as we know such tools are not available (at least not to most programmers).\n* The exception-handling run-time support takes up too much space.\nThis can be the case in small (usually embedded) systems.\nHowever, before abandoning exceptions consider what space consistent error-handling using error-codes would require\nand what failure to catch an error would cost.\n\nMany, possibly most, problems with exceptions stem from historical needs to interact with messy old code.\n\nThe fundamental arguments for the use of exceptions are\n\n* They clearly differentiate between erroneous return and ordinary return\n* They cannot be forgotten or ignored\n* They can be used systematically\n\nRemember\n\n* Exceptions are for reporting errors (in C++; other languages can have different uses for exceptions).\n* Exceptions are not for errors that can be handled locally.\n* Don't try to catch every exception in every function (that's tedious, clumsy, and leads to slow code).\n* Exceptions are not for errors that require instant termination of a module/system after a non-recoverable error.\n\n##### Example\n\n    ???\n\n##### Alternative\n\n* [RAII](#re-raii)\n* Contracts/assertions: Use GSL's `Expects` and `Ensures` (until we get language support for contracts)\n\n### <a name=\"rnr-lots-of-files\"></a>NR.4: Don't insist on placing each class definition in its own source file\n\n##### Reason\n\nThe resulting number of files from placing each class in its own file are hard to manage and can slow down compilation.\nIndividual classes are rarely a good logical unit of maintenance and distribution.\n\n##### Example\n\n    ???\n\n##### Alternative\n\n* Use namespaces containing logically cohesive sets of classes and functions.\n\n### <a name=\"rnr-two-phase-init\"></a>NR.5: Don't use two-phase initialization\n\n##### Reason\n\nSplitting initialization into two leads to weaker invariants,\nmore complicated code (having to deal with semi-constructed objects),\nand errors (when we didn't deal correctly with semi-constructed objects consistently).\n\n##### Note\n\nSometimes also called two-stage construction.\n\n##### Example, bad\n\n    // Old conventional style: many problems\n\n    class Picture\n    {\n        int mx;\n        int my;\n        int * data;\n    public:\n        // main problem: constructor does not fully construct\n        Picture(int x, int y)\n        {\n            mx = x;         // also bad: assignment in constructor body\n                            // rather than in member initializer\n            my = y;\n            data = nullptr; // also bad: constant initialization in constructor\n                            // rather than in member initializer\n        }\n\n        ~Picture()\n        {\n            Cleanup();\n        }\n\n        // ...\n\n        // bad: two-phase initialization\n        bool Init()\n        {\n            // invariant checks\n            if (mx <= 0 || my <= 0) {\n                return false;\n            }\n            if (data) {\n                return false;\n            }\n            data = (int*) malloc(mx*my*sizeof(int));   // also bad: owning raw * and malloc\n            return data != nullptr;\n        }\n\n        // also bad: no reason to make cleanup a separate function\n        void Cleanup()\n        {\n            if (data) free(data);\n            data = nullptr;\n        }\n    };\n\n    Picture picture(100, 0); // not ready-to-use picture here\n    // this will fail..\n    if (!picture.Init()) {\n        puts(\"Error, invalid picture\");\n    }\n    // now have an invalid picture object instance.\n\n##### Example, good\n\n    class Picture\n    {\n        int mx;\n        int my;\n        vector<int> data;\n\n        static int check_size(int size)\n        {\n            // invariant check\n            Expects(size > 0);\n            return size;\n        }\n\n    public:\n        // even better would be a class for a 2D Size as one single parameter\n        Picture(int x, int y)\n            : mx(check_size(x))\n            , my(check_size(y))\n            // now we know x and y have a valid size\n            , data(mx * my) // will throw std::bad_alloc on error\n        {\n            // picture is ready-to-use\n        }\n\n        // compiler generated dtor does the job. (also see C.21)\n\n        // ...\n    };\n\n    Picture picture1(100, 100);\n    // picture1 is ready-to-use here...\n\n    // not a valid size for y,\n    // default contract violation behavior will call std::terminate then\n    Picture picture2(100, 0);\n    // not reach here...\n\n##### Alternative\n\n* Always establish a class invariant in a constructor.\n* Don't define an object before it is needed.\n\n### <a name=\"rnr-goto-exit\"></a>NR.6: Don't place all cleanup actions at the end of a function and `goto exit`\n\n##### Reason\n\n`goto` is error-prone.\nThis technique is a pre-exception technique for RAII-like resource and error handling.\n\n##### Example, bad\n\n    void do_something(int n)\n    {\n        if (n < 100) goto exit;\n        // ...\n        int* p = (int*) malloc(n);\n        // ...\n        if (some_error) goto exit;\n        // ...\n    exit:\n        free(p);\n    }\n\nand spot the bug.\n\n##### Alternative\n\n* Use exceptions and [RAII](#re-raii)\n* for non-RAII resources, use [`finally`](#re-finally).\n\n### <a name=\"rnr-protected-data\"></a>NR.7: Don't make data members `protected`\n\n##### Reason\n\n`protected` data is a source of errors.\n`protected` data can be manipulated from an unbounded amount of code in various places.\n`protected` data is the class hierarchy equivalent to global data.\n\n##### Example\n\n    ???\n\n##### Alternative\n\n* [Avoid `protected` data](#rh-protected)\n\n\n# <a name=\"s-references\"></a>RF: References\n\nMany coding standards, rules, and guidelines have been written for C++, and especially for specialized uses of C++.\nMany\n\n* focus on lower-level issues, such as the spelling of identifiers\n* are written by C++ novices\n* see \"stopping programmers from doing unusual things\" as their primary aim\n* aim at portability across many compilers (some 10 years old)\n* are written to preserve decades old code bases\n* aim at a single application domain\n* are downright counterproductive\n* are ignored (must be ignored by programmers to get their work done well)\n\nA bad coding standard is worse than no coding standard.\nHowever an appropriate set of guidelines are much better than no standards: \"Form is liberating.\"\n\nWhy can't we just have a language that allows all we want and disallows all we don't want (\"a perfect language\")?\nFundamentally, because affordable languages (and their tool chains) also serve people with needs that differ from yours and serve more needs than you have today.\nAlso, your needs change over time and a general-purpose language is needed to allow you to adapt.\nA language that is ideal for today would be overly restrictive tomorrow.\n\nCoding guidelines adapt the use of a language to specific needs.\nThus, there cannot be a single coding style for everybody.\nWe expect different organizations to provide additions, typically with more restrictions and firmer style rules.\n\nReference sections:\n\n* [RF.rules: Coding rules](#ss-rules)\n* [RF.books: Books with coding guidelines](#ss-books)\n* [RF.C++: C++ Programming (C++11/C++14/C++17)](#ss-cplusplus)\n* [RF.web: Websites](#ss-web)\n* [RS.video: Videos about \"modern C++\"](#ss-vid)\n* [RF.man: Manuals](#ss-man)\n* [RF.core: Core Guidelines materials](#ss-core)\n\n## <a name=\"ss-rules\"></a>RF.rules: Coding rules\n\n* [AUTOSAR Guidelines for the use of the C++14 language in critical and safety-related systems v22.11](https://www.autosar.org/fileadmin/standards/R22-11/AP/AUTOSAR_RS_CPP14Guidelines.pdf) (obsolete, replaced by [MISRA C++:2023](https://misra.org.uk/product/misra-cpp2023/))\n* [Boost Library Requirements and Guidelines](https://www.boost.org/development/requirements.html).\n  ???.\n* [Bloomberg: BDE C++ Coding](https://github.com/bloomberg/bde/wiki/CodingStandards.pdf).\n  Has a strong emphasis on code organization and layout.\n* Facebook: ???\n* [GCC Coding Conventions](https://gcc.gnu.org/codingconventions.html).\n  C++03 and (reasonably) a bit backwards looking.\n* [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html).\n  Geared toward C++17 and (also) older code bases. Google experts are now actively collaborating here on helping to improve these Guidelines, and hopefully to merge efforts so these can be a modern common set they could also recommend.\n* [JSF++: JOINT STRIKE FIGHTER AIR VEHICLE C++ CODING STANDARDS](https://www.stroustrup.com/JSF-AV-rules.pdf).\n  Document Number 2RDU00001 Rev C. December 2005.\n  For flight control software.\n  For hard-real-time.\n  This means that it is necessarily very restrictive (\"if the program fails somebody dies\").\n  For example, no free store allocation or deallocation is allowed to occur after the plane takes off (no memory overflow and no fragmentation allowed).\n  No exception is allowed to be used (because there was no available tool for guaranteeing that an exception would be handled within a fixed short time).\n  Libraries used have to have been approved for mission critical applications.\n  Any similarities to this set of guidelines are unsurprising because Bjarne Stroustrup was an author of JSF++.\n  Recommended, but note its very specific focus.\n* [MISRA C++:2023 Guidelines for the use C++17 in critical systems](https://misra.org.uk/product/misra-cpp2023/).\n* [Using C++ in Mozilla Code](https://firefox-source-docs.mozilla.org/code-quality/coding-style/using_cxx_in_firefox_code.html).\n  As the name indicates, this aims for portability across many (old) compilers.\n  As such, it is restrictive.\n* [Geosoft.no: C++ Programming Style Guidelines](https://geosoft.no/development/cppstyle.html).\n  ???.\n* [Possibility.com: C++ Coding Standard](https://www.possibility.com/Cpp/CppCodingStandard.html).\n  ???.\n* [SEI CERT: Secure C++ Coding Standard](https://wiki.sei.cmu.edu/confluence/x/Wnw-BQ).\n  A very nicely done set of rules (with examples and rationales) done for security-sensitive code.\n  Many of their rules apply generally.\n* [High Integrity C++ Coding Standard](https://www.codingstandard.com/).\n* [llvm](https://llvm.org/docs/CodingStandards.html).\n  Somewhat brief, based on C++14, and (not unreasonably) adjusted to its domain.\n* ???\n\n## <a name=\"ss-books\"></a>RF.books: Books with coding guidelines\n\n* [Meyers96](#Meyers96) Scott Meyers: *More Effective C++*. Addison-Wesley 1996.\n* [Meyers97](#Meyers97) Scott Meyers: *Effective C++, Second Edition*. Addison-Wesley 1997.\n* [Meyers01](#Meyers01) Scott Meyers: *Effective STL*. Addison-Wesley 2001.\n* [Meyers05](#Meyers05) Scott Meyers: *Effective C++, Third Edition*. Addison-Wesley 2005.\n* [Meyers15](#Meyers15) Scott Meyers: *Effective Modern C++*. O'Reilly 2015.\n* [SuttAlex05](#SuttAlex05) Sutter and Alexandrescu: *C++ Coding Standards*. Addison-Wesley 2005. More a set of meta-rules than a set of rules. Pre-C++11.\n* [Stroustrup05](#Stroustrup05) Bjarne Stroustrup: [A rationale for semantically enhanced library languages](https://www.stroustrup.com/SELLrationale.pdf).\n  LCSD05. October 2005.\n* [Stroustrup14](#Stroustrup05) Stroustrup: [A Tour of C++](https://www.stroustrup.com/Tour.html).\n  Addison-Wesley 2014.\n  Each chapter ends with an advice section consisting of a set of recommendations.\n* [Stroustrup13](#Stroustrup13) Stroustrup: [The C++ Programming Language (4th Edition)](https://www.stroustrup.com/4th.html).\n  Addison-Wesley 2013.\n  Each chapter ends with an advice section consisting of a set of recommendations.\n* Stroustrup: [Style Guide](https://www.stroustrup.com/Programming/PPP-style.pdf)\n  for [Programming: Principles and Practice using C++](https://www.stroustrup.com/programming.html).\n  Mostly low-level naming and layout rules.\n  Primarily a teaching tool.\n\n## <a name=\"ss-cplusplus\"></a>RF.C++: C++ Programming (C++11/C++14)\n\n* [TC++PL4](https://www.stroustrup.com/4th.html):\nA thorough description of the C++ language and standard libraries for experienced programmers.\n* [Tour++](https://www.stroustrup.com/Tour.html):\nAn overview of the C++ language and standard libraries for experienced programmers.\n* [Programming: Principles and Practice using C++](https://www.stroustrup.com/programming.html):\nA textbook for beginners and relative novices.\n\n## <a name=\"ss-web\"></a>RF.web: Websites\n\n* [isocpp.org](https://isocpp.org)\n* [Bjarne Stroustrup's home pages](https://www.stroustrup.com)\n* [WG21](https://www.open-std.org/jtc1/sc22/wg21/)\n* [Boost](https://www.boost.org)<a name=\"Boost\"></a>\n* [Adobe open source](https://opensource.adobe.com/)\n* [Poco libraries](https://pocoproject.org/)\n* Sutter's Mill?\n* ???\n\n## <a name=\"ss-vid\"></a>RS.video: Videos about \"modern C++\"\n\n* Bjarne Stroustrup: [C++11 Style](https://learn.microsoft.com/en-us/shows/goingnative-2012/keynote-bjarne-stroustrup-cpp11-style). 2012.\n* Bjarne Stroustrup: [The Essence of C++: With Examples in C++84, C++98, C++11, and C++14](https://learn.microsoft.com/en-us/shows/goingnative-2013/opening-keynote-bjarne-stroustrup). 2013\n* All the talks from [CppCon &#8217;14](https://isocpp.org/blog/2014/11/cppcon-videos-c9)\n* Bjarne Stroustrup: [The essence of C++](https://www.youtube.com/watch?v=86xWVb4XIyE) at the University of Edinburgh. 2014.\n* Bjarne Stroustrup: [The Evolution of C++ Past, Present and Future](https://www.youtube.com/watch?v=_wzc7a3McOs). CppCon 2016 keynote.\n* Bjarne Stroustrup: [Make Simple Tasks Simple!](https://www.youtube.com/watch?v=nesCaocNjtQ). CppCon 2014 keynote.\n* Bjarne Stroustrup: [Writing Good C++14](https://www.youtube.com/watch?v=1OEu9C51K2A). CppCon 2015 keynote about the Core Guidelines.\n* Herb Sutter: [Writing Good C++14... By Default](https://www.youtube.com/watch?v=hEx5DNLWGgA). CppCon 2015 keynote about the Core Guidelines.\n* CppCon 15\n* ??? C++ Next\n* ??? Meting C++\n* ??? more ???\n\n## <a name=\"ss-man\"></a>RF.man: Manuals\n\n* ISO C++ Standard C++11.\n* ISO C++ Standard C++14.\n* [ISO C++ Standard C++17](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4606.pdf). Committee Draft.\n* [Palo Alto \"Concepts\" TR](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3351.pdf).\n* [ISO C++ Concepts TS](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4553.pdf).\n* [WG21 Ranges report](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4569.pdf). Draft.\n\n\n## <a name=\"ss-core\"></a>RF.core: Core Guidelines materials\n\nThis section contains materials that have been useful for presenting the core guidelines and the ideas behind them:\n\n* [Our documents directory](https://github.com/isocpp/CppCoreGuidelines/tree/master/docs)\n* Stroustrup, Sutter, and Dos Reis: [A brief introduction to C++'s model for type- and resource-safety](https://www.stroustrup.com/resource-model.pdf). A paper with lots of examples.\n* Sergey Zubkov: [a Core Guidelines talk](https://www.youtube.com/watch?v=DyLwdl_6vmU)\nand here are the [slides](https://www.slideshare.net/slideshow/c-core-guidelines-72335317/72335317). In Russian. 2017.\n* Neil MacIntosh: [The Guideline Support Library: One Year Later](https://www.youtube.com/watch?v=_GhNnCuaEjo). CppCon 2016.\n* Bjarne Stroustrup: [Writing Good C++14](https://www.youtube.com/watch?v=1OEu9C51K2A). CppCon 2015 keynote.\n* Herb Sutter: [Writing Good C++14... By Default](https://www.youtube.com/watch?v=hEx5DNLWGgA). CppCon 2015 keynote.\n* Peter Sommerlad: [C++ Core Guidelines - Modernize your C++ Code Base](https://www.youtube.com/watch?v=fQ926v4ZzAM). ACCU 2017.\n* Bjarne Stroustrup: [No Littering!](https://www.youtube.com/watch?v=01zI9kV4h8c). Bay Area ACCU 2016.\nIt gives some idea of the ambition level for the Core Guidelines.\n\nNote that slides for CppCon presentations are available (links with the posted videos).\n\nContributions to this list would be most welcome.\n\n## <a name=\"ss-ack\"></a>Acknowledgements\n\nThanks to the many people who contributed rules, suggestions, supporting information, references, etc.:\n\n* Peter Juhl\n* Neil MacIntosh\n* Axel Naumann\n* Andrew Pardoe\n* Gabriel Dos Reis\n* Zhuang, Jiangang (Jeff)\n* Sergey Zubkov\n\nand see the contributor list on the github.\n\n# <a name=\"s-profile\"></a>Pro: Profiles\n\nIdeally, we would follow all of the guidelines.\nThat would give the cleanest, most regular, least error-prone, and often the fastest code.\nUnfortunately, that is usually impossible because we have to fit our code into large code bases and use existing libraries.\nOften, such code has been written over decades and does not follow these guidelines.\nWe must aim for [gradual adoption](#s-modernizing).\n\nWhatever strategy for gradual adoption we adopt, we need to be able to apply sets of related guidelines to address some set\nof problems first and leave the rest until later.\nA similar idea of \"related guidelines\" becomes important when some, but not all, guidelines are considered relevant to a code base\nor if a set of specialized guidelines is to be applied for a specialized application area.\nWe call such a set of related guidelines a \"profile\".\nWe aim for such a set of guidelines to be coherent so that they together help us reach a specific goal, such as \"absence of range errors\"\nor \"static type safety.\"\nEach profile is designed to eliminate a class of errors.\nEnforcement of \"random\" rules in isolation is more likely to be disruptive to a code base than delivering a definite improvement.\n\nA \"profile\" is a set of deterministic and portably enforceable subset of rules (i.e., restrictions) that are designed to achieve a specific guarantee.\n\"Deterministic\" means they require only local analysis and could be implemented in a compiler (though they don't need to be).\n\"Portably enforceable\" means they are like language rules, so programmers can count on different enforcement tools giving the same answer for the same code.\n\nCode written to be warning-free using such a language profile is considered to conform to the profile.\nConforming code is considered to be safe by construction with regard to the safety properties targeted by that profile.\nConforming code will not be the root cause of errors for that property,\nalthough such errors might be introduced into a program by other code, libraries or the external environment.\nA profile might also introduce additional library types to ease conformance and encourage correct code.\n\nProfiles summary:\n\n* [Pro.type: Type safety](#ss-type)\n* [Pro.bounds: Bounds safety](#ss-bounds)\n* [Pro.lifetime: Lifetime safety](#ss-lifetime)\n\nIn the future, we expect to define many more profiles and add more checks to existing profiles.\nCandidates include:\n\n* narrowing arithmetic promotions/conversions (likely part of a separate safe-arithmetic profile)\n* arithmetic cast from negative floating point to unsigned integral type (ditto)\n* selected undefined behavior: Start with Gabriel Dos Reis's UB list developed for the WG21 study group\n* selected unspecified behavior: Addressing portability concerns.\n* `const` violations: Mostly done by compilers already, but we can catch inappropriate casting and underuse of `const`.\n\nEnabling a profile is implementation defined; typically, it is set in the analysis tool used.\n\nTo suppress enforcement of a profile check, place a `suppress` annotation on a language contract. For example:\n\n    [[suppress(\"bounds\")]] char* raw_find(char* p, int n, char x)    // find x in p[0]..p[n - 1]\n    {\n        // ...\n    }\n\nNow `raw_find()` can scramble memory to its heart's content.\nObviously, suppression should be very rare.\n\n## <a name=\"ss-type\"></a>Pro.safety: Type-safety profile\n\nThis profile makes it easier to construct code that uses types correctly and avoids inadvertent type punning.\nIt does so by focusing on removing the primary sources of type violations, including unsafe uses of casts and unions.\n\nFor the purposes of this section,\ntype-safety is defined to be the property that a variable is not used in a way that doesn't obey the rules for the type of its definition.\nMemory accessed as a type `T` should not be valid memory that actually contains an object of an unrelated type `U`.\nNote that the safety is intended to be complete when combined also with [Bounds safety](#ss-bounds) and [Lifetime safety](#ss-lifetime).\n\nAn implementation of this profile shall recognize the following patterns in source code as non-conforming and issue a diagnostic.\n\nType safety profile summary:\n\n* <a name=\"pro-type-avoidcasts\"></a>Type.1: [Avoid casts](#res-casts):\n\n  1. <a name=\"pro-type-reinterpretcast\"></a>Don't use `reinterpret_cast`; A strict version of [Avoid casts](#res-casts) and [prefer named casts](#res-casts-named).\n  2. <a name=\"pro-type-arithmeticcast\"></a>Don't use `static_cast` for arithmetic types; A strict version of [Avoid casts](#res-casts) and [prefer named casts](#res-casts-named).\n  3. <a name=\"pro-type-identitycast\"></a>Don't cast between pointer types where the source type and the target type are the same; A strict version of [Avoid casts](#res-casts).\n  4. <a name=\"pro-type-implicitpointercast\"></a>Don't cast between pointer types when the conversion could be implicit; A strict version of [Avoid casts](#res-casts).\n* <a name=\"pro-type-downcast\"></a>Type.2: Don't use `static_cast` to downcast:\n[Use `dynamic_cast` instead](#rh-dynamic_cast).\n* <a name=\"pro-type-constcast\"></a>Type.3: Don't use `const_cast` to cast away `const` (i.e., at all):\n[Don't cast away const](#res-casts-const).\n* <a name=\"pro-type-cstylecast\"></a>Type.4: Don't use C-style `(T)expression` or functional `T(expression)` casts:\nPrefer [construction](#res-construct) or [named casts](#res-casts-named) or `T{expression}`.\n* <a name=\"pro-type-init\"></a>Type.5: Don't use a variable before it has been initialized:\n[always initialize](#res-always).\n* <a name=\"pro-type-memberinit\"></a>Type.6: Always initialize a data member:\n[always initialize](#res-always),\npossibly using [default constructors](#rc-default0) or\n[default member initializers](#rc-in-class-initializer).\n* <a name=\"pro-type-union\"></a>Type.7: Avoid naked union:\n[Use `variant` instead](#ru-naked).\n* <a name=\"pro-type-varargs\"></a>Type.8: Avoid varargs:\n[Don't use `va_arg` arguments](#f-varargs).\n\n##### Impact\n\nWith the type-safety profile you can trust that every operation is applied to a valid object.\nAn exception can be thrown to indicate errors that cannot be detected statically (at compile time).\nNote that this type-safety can be complete only if we also have [Bounds safety](#ss-bounds) and [Lifetime safety](#ss-lifetime).\nWithout those guarantees, a region of memory could be accessed independent of which object, objects, or parts of objects are stored in it.\n\n\n## <a name=\"ss-bounds\"></a>Pro.bounds: Bounds safety profile\n\nThis profile makes it easier to construct code that operates within the bounds of allocated blocks of memory.\nIt does so by focusing on removing the primary sources of bounds violations: pointer arithmetic and array indexing.\nOne of the core features of this profile is to restrict pointers to only refer to single objects, not arrays.\n\nWe define bounds-safety to be the property that a program does not use an object to access memory outside of the range that was allocated for it.\nBounds safety is intended to be complete only when combined with [Type safety](#ss-type) and [Lifetime safety](#ss-lifetime),\nwhich cover other unsafe operations that allow bounds violations.\n\nBounds safety profile summary:\n\n* <a name=\"pro-bounds-arithmetic\"></a>Bounds.1: Don't use pointer arithmetic. Use `span` instead:\n[Pass pointers to single objects (only)](#ri-array) and [Keep pointer arithmetic simple](#res-ptr).\n* <a name=\"pro-bounds-arrayindex\"></a>Bounds.2: Only index into arrays using constant expressions:\n[Pass pointers to single objects (only)](#ri-array) and [Keep pointer arithmetic simple](#res-ptr).\n* <a name=\"pro-bounds-decay\"></a>Bounds.3: No array-to-pointer decay:\n[Pass pointers to single objects (only)](#ri-array) and [Keep pointer arithmetic simple](#res-ptr).\n* <a name=\"pro-bounds-stdlib\"></a>Bounds.4: Don't use standard-library functions and types that are not bounds-checked:\n[Use the standard library in a type-safe manner](#rsl-bounds).\n\n##### Impact\n\nBounds safety implies that access to an object - notably arrays - does not access beyond the object's memory allocation.\nThis eliminates a large class of insidious and hard-to-find errors, including the (in)famous \"buffer overflow\" errors.\nThis closes security loopholes as well as a prominent source of memory corruption (when writing out of bounds).\nEven if an out-of-bounds access is \"just a read\", it can lead to invariant violations (when the accessed isn't of the assumed type)\nand \"mysterious values.\"\n\n\n## <a name=\"ss-lifetime\"></a>Pro.lifetime: Lifetime safety profile\n\nAccessing through a pointer that doesn't point to anything is a major source of errors,\nand very hard to avoid in many traditional C or C++ styles of programming.\nFor example, a pointer might be uninitialized, the `nullptr`, point beyond the range of an array, or to a deleted object.\n\n[See the current design specification here.](https://github.com/isocpp/CppCoreGuidelines/blob/master/docs/Lifetime.pdf)\n\nLifetime safety profile summary:\n\n* <a name=\"pro-lifetime-invalid-deref\"></a>Lifetime.1: Don't dereference a possibly invalid pointer:\n[detect or avoid](#res-deref).\n\n##### Impact\n\nOnce completely enforced through a combination of style rules, static analysis, and library support, this profile\n\n* eliminates one of the major sources of nasty errors in C++\n* eliminates a major source of potential security violations\n* improves performance by eliminating redundant \"paranoia\" checks\n* increases confidence in correctness of code\n* avoids undefined behavior by enforcing a key C++ language rule\n\n\n# <a name=\"s-gsl\"></a>GSL: Guidelines support library\n\nThe GSL is a small library of facilities designed to support this set of guidelines.\nWithout these facilities, the guidelines would have to be far more restrictive on language details.\n\nThe Core Guidelines support library is defined in namespace `gsl` and the names might be aliases for standard library or other well-known library names. Using the (compile-time) indirection through the `gsl` namespace allows for experimentation and for local variants of the support facilities.\n\nThe GSL is header only, and can be found at [GSL: Guidelines support library](https://github.com/Microsoft/GSL).\nThe support library facilities are designed to be extremely lightweight (zero-overhead) so that they impose no overhead compared to using conventional alternatives.\nWhere desirable, they can be \"instrumented\" with additional functionality (e.g., checks) for tasks such as debugging.\n\nThese Guidelines use types from the standard (e.g., C++17) in addition to ones from the GSL.\nFor example, we assume a `variant` type, but this is not currently in GSL.\nEventually, use [the one voted into C++17](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0088r3.html).\n\nSome of the GSL types listed below might not be supported in the library you use due to technical reasons such as limitations in the current versions of C++.\nTherefore, please consult your GSL documentation to find out more.\n\nFor each GSL type below we state an invariant for that type. That invariant holds as long as user code only changes the state of a GSL object using the type's provided member/free functions (i.e., user code does not bypass the type's interface to change the object's value/bits by violating any other Guidelines rule).\n\nSummary of GSL components:\n\n* [GSL.view: Views](#ss-views)\n* [GSL.owner: Ownership pointers](#ss-ownership)\n* [GSL.assert: Assertions](#ss-assertions)\n* [GSL.util: Utilities](#ss-utilities)\n* [GSL.concept: Concepts](#ss-gsl-concepts)\n\nWe plan for a \"ISO C++ standard style\" semi-formal specification of the GSL.\n\nWe rely on the ISO C++ Standard Library and hope for parts of the GSL to be absorbed into the standard library.\n\n## <a name=\"ss-views\"></a>GSL.view: Views\n\nThese types allow the user to distinguish between owning and non-owning pointers and between pointers to a single object and pointers to the first element of a sequence.\n\nThese \"views\" are never owners.\n\nReferences are never owners (see [R.4](#rr-ref)). Note: References have many opportunities to outlive the objects they refer to (returning a local variable by reference, holding a reference to an element of a vector and doing `push_back`, binding to `std::max(x, y + 1)`, etc). The Lifetime safety profile aims to address those things, but even so `owner<T&>` does not make sense and is discouraged.\n\nThe names are mostly ISO standard-library style (lower case and underscore):\n\n* `T*`      // The `T*` is not an owner, might be null; assumed to be pointing to a single element.\n* `T&`      // The `T&` is not an owner and can never be a \"null reference\"; references are always bound to objects.\n\nThe \"raw-pointer\" notation (e.g. `int*`) is assumed to have its most common meaning; that is, a pointer points to an object, but does not own it.\nOwners should be converted to resource handles (e.g., `unique_ptr` or `vector<T>`) or marked `owner<T*>`.\n\n* `owner<T*>`   // a `T*` that owns the object pointed/referred to; might be `nullptr`.\n\n`owner` is used to mark owning pointers in code that cannot be upgraded to use proper resource handles.\nReasons for that include:\n\n* Cost of conversion.\n* The pointer is used with an ABI.\n* The pointer is part of the implementation of a resource handle.\n\nAn `owner<T>` differs from a resource handle for a `T` by still requiring an explicit `delete`.\n\nAn `owner<T>` is assumed to refer to an object on the free store (heap).\n\nIf something is not supposed to be `nullptr`, say so:\n\n* `not_null<T>`   // `T` is usually a pointer type (e.g., `not_null<int*>` and `not_null<owner<Foo*>>`) that must not be `nullptr`.\n  `T` can be any type for which `==nullptr` is meaningful.\n\n* `span<T>`       // `[p:p+n)`, constructor from `{p, q}` and `{p, n}`; `T` is the pointer type\n* `span_p<T>`     // `{p, predicate}` `[p:q)` where `q` is the first element for which `predicate(*p)` is true\n\nA `span<T>` refers to zero or more mutable `T`s unless `T` is a `const` type. All accesses to elements of the span, notably via `operator[]`, are guaranteed to be bounds-checked by default.\n\n> Note: GSL's `span` (initially called `array_view`) was proposed for inclusion in the C++ standard library, and was adopted (with changes to its name and interface) except only that `std::span` does not provide for guaranteed bounds checking. Therefore GSL changed `span`'s name and interface to track `std::span` and should be exactly the same as `std::span`, and the only difference should be that GSL `span` is fully bounds-safe by default. If bounds-safety might affect its interface, then those change proposals should be brought back via the ISO C++ committee to keep `gsl::span` interface-compatible with `std::span`. If a future evolution of `std::span` adds bounds checking, `gsl::span` can be removed.\n\n\"Pointer arithmetic\" is best done within `span`s.\nA `char*` that points to more than one `char` but is not a C-style string (e.g., a pointer into an input buffer) should be represented by a `span`.\n\n* `zstring`    // a `char*` supposed to be a C-style string; that is, a zero-terminated sequence of `char` or `nullptr`\n* `czstring`   // a `const char*` supposed to be a C-style string; that is, a zero-terminated sequence of `const` `char` or `nullptr`\n\nLogically, those last two aliases are not needed, but we are not always logical, and they make the distinction between a pointer to one `char` and a pointer to a C-style string explicit.\nA sequence of characters that is not assumed to be zero-terminated should be a `span<char>`, or if that is impossible because of ABI issues a `char*`, rather than a `zstring`.\n\n\nUse `not_null<zstring>` for C-style strings that cannot be `nullptr`. ??? Do we need a name for `not_null<zstring>`? or is its ugliness a feature?\n\n## <a name=\"ss-ownership\"></a>GSL.owner: Ownership pointers\n\n* `unique_ptr<T>`     // unique ownership: `std::unique_ptr<T>`\n* `shared_ptr<T>`     // shared ownership: `std::shared_ptr<T>` (a counted pointer)\n* `stack_array<T>`    // A stack-allocated array. The number of elements is determined at construction and fixed thereafter. The elements are mutable unless `T` is a `const` type.\n* `dyn_array<T>`      // A container, non-growing dynamically allocated array. The number of elements is determined at construction and fixed thereafter.\n  The elements are mutable unless `T` is a `const` type. Basically a `span` that allocates and owns its elements.\n\n## <a name=\"ss-assertions\"></a>GSL.assert: Assertions\n\n* `Expects`     // precondition assertion. Currently placed in function bodies. Later, should be moved to declarations.\n                // `Expects(p)` terminates the program unless `p == true`\n                // `Expects` is under control of some options (enforcement, error message, alternatives to terminate)\n* `Ensures`     // postcondition assertion. Currently placed in function bodies. Later, should be moved to declarations.\n\nThese assertions are currently macros (yuck!) and must appear in function definitions (only)\npending standard committee decisions on contracts and assertion syntax.\nSee [the contract proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0380r1.pdf); using the attribute syntax,\nfor example, `Expects(p)` will become `[[expects: p]]`.\n\n## <a name=\"ss-utilities\"></a>GSL.util: Utilities\n\n* `finally`        // `finally(f)` makes a `final_action{f}` with a destructor that invokes `f`\n* `narrow_cast`    // `narrow_cast<T>(x)` is `static_cast<T>(x)`\n* `narrow`         // `narrow<T>(x)` is `static_cast<T>(x)` if `static_cast<T>(x) == x` with no signedness promotions, or it throws `narrowing_error` (e.g., `narrow<unsigned>(-42)` throws)\n* `[[implicit]]`   // \"Marker\" to put on single-argument constructors to explicitly make them non-explicit.\n* `move_owner`     // `p = move_owner(q)` means `p = q` but ???\n* `joining_thread` // a RAII style version of `std::thread` that joins.\n* `index`          // a type to use for all container and array indexing (currently an alias for `ptrdiff_t`)\n\n## <a name=\"ss-gsl-concepts\"></a>GSL.concept: Concepts\n\nThese concepts (type predicates) are borrowed from\nAndrew Sutton's Origin library,\nthe Range proposal,\nand the ISO WG21 Palo Alto TR.\nMany of them are very similar to what became part of the ISO C++ standard in C++20.\n\n* `String`\n* `Number`\n* `Boolean`\n* `Range`              // in C++20, `std::ranges::range`\n* `Sortable`           // in C++20, `std::sortable`\n* `EqualityComparable` // in C++20, `std::equality_comparable`\n* `Convertible`        // in C++20, `std::convertible_to`\n* `Common`             // in C++20, `std::common_with`\n* `Integral`           // in C++20, `std::integral`\n* `SignedIntegral`     // in C++20, `std::signed_integral`\n* `SemiRegular`        // in C++20, `std::semiregular`\n* `Regular`            // in C++20, `std::regular`\n* `TotallyOrdered`     // in C++20, `std::totally_ordered`\n* `Function`           // in C++20, `std::invocable`\n* `RegularFunction`    // in C++20, `std::regular_invocable`\n* `Predicate`          // in C++20, `std::predicate`\n* `Relation`           // in C++20, `std::relation`\n* ...\n\n### <a name=\"ss-gsl-smartptrconcepts\"></a>GSL.ptr: Smart pointer concepts\n\n* `Pointer`  // A type with `*`, `->`, `==`, and default construction (default construction is assumed to set the singular \"null\" value)\n* `Unique_pointer`  // A type that matches `Pointer`, is movable, and is not copyable\n* `Shared_pointer`   // A type that matches `Pointer`, and is copyable\n\n# <a name=\"s-naming\"></a>NL: Naming and layout suggestions\n\nConsistent naming and layout are helpful.\nIf for no other reason because it minimizes \"my style is better than your style\" arguments.\nHowever, there are many, many, different styles around and people are passionate about them (pro and con).\nAlso, most real-world projects include code from many sources, so standardizing on a single style for all code is often impossible.\nAfter many requests for guidance from users, we present a set of rules that you might use if you have no better ideas, but the real aim is consistency, rather than any particular rule set.\nIDEs and tools can help (as well as hinder).\n\nNaming and layout rules:\n\n* [NL.1: Don't say in comments what can be clearly stated in code](#rl-comments)\n* [NL.2: State intent in comments](#rl-comments-intent)\n* [NL.3: Keep comments crisp](#rl-comments-crisp)\n* [NL.4: Maintain a consistent indentation style](#rl-indent)\n* [NL.5: Avoid encoding type information in names](#rl-name-type)\n* [NL.7: Make the length of a name roughly proportional to the length of its scope](#rl-name-length)\n* [NL.8: Use a consistent naming style](#rl-name)\n* [NL.9: Use `ALL_CAPS` for macro names only](#rl-all-caps)\n* [NL.10: Prefer `underscore_style` names](#rl-camel)\n* [NL.11: Make literals readable](#rl-literals)\n* [NL.15: Use spaces sparingly](#rl-space)\n* [NL.16: Use a conventional class member declaration order](#rl-order)\n* [NL.17: Use K&R-derived layout](#rl-knr)\n* [NL.18: Use C++-style declarator layout](#rl-ptr)\n* [NL.19: Avoid names that are easily misread](#rl-misread)\n* [NL.20: Don't place two statements on the same line](#rl-stmt)\n* [NL.21: Declare one name (only) per declaration](#rl-dcl)\n* [NL.25: Don't use `void` as an argument type](#rl-void)\n* [NL.26: Use conventional `const` notation](#rl-const)\n* [NL.27: Use a `.cpp` suffix for code files and `.h` for interface files](#rl-file-suffix)\n\nMost of these rules are aesthetic and programmers hold strong opinions.\nIDEs also tend to have defaults and a range of alternatives.\nThese rules are suggested defaults to follow unless you have reasons not to.\n\nWe have had comments to the effect that naming and layout are so personal and/or arbitrary that we should not try to \"legislate\" them.\nWe are not \"legislating\" (see the previous paragraph).\nHowever, we have had many requests for a set of naming and layout conventions to use when there are no external constraints.\n\nMore specific and detailed rules are easier to enforce.\n\nThese rules bear a strong resemblance to the recommendations in the [PPP Style Guide](https://www.stroustrup.com/Programming/PPP-style.pdf)\nwritten in support of Stroustrup's [Programming: Principles and Practice using C++](https://www.stroustrup.com/programming.html).\n\n### <a name=\"rl-comments\"></a>NL.1: Don't say in comments what can be clearly stated in code\n\n##### Reason\n\nCompilers do not read comments.\nComments are less precise than code.\nComments are not updated as consistently as code.\n\n##### Example, bad\n\n    auto x = m * v1 + vv;   // multiply m with v1 and add the result to vv\n\n##### Enforcement\n\nBuild an AI program that interprets colloquial English text and see if what is said could be better expressed in C++.\n\n### <a name=\"rl-comments-intent\"></a>NL.2: State intent in comments\n\n##### Reason\n\nCode says what is done, not what is supposed to be done. Often intent can be stated more clearly and concisely than the implementation.\n\n##### Example\n\n    void stable_sort(Sortable& c)\n        // sort c in the order determined by <, keep equal elements (as defined by ==) in\n        // their original relative order\n    {\n        // ... quite a few lines of non-trivial code ...\n    }\n\n##### Note\n\nIf the comment and the code disagree, both are likely to be wrong.\n\n### <a name=\"rl-comments-crisp\"></a>NL.3: Keep comments crisp\n\n##### Reason\n\nVerbosity slows down understanding and makes the code harder to read by spreading it around in the source file.\n\n##### Note\n\nUse intelligible English.\nI might be fluent in Danish, but most programmers are not; the maintainers of my code might not be.\nAvoid SMS lingo and watch your grammar, punctuation, and capitalization.\nAim for professionalism, not \"cool.\"\n\n##### Enforcement\n\nnot possible.\n\n### <a name=\"rl-indent\"></a>NL.4: Maintain a consistent indentation style\n\n##### Reason\n\nReadability. Avoidance of \"silly mistakes.\"\n\n##### Example, bad\n\n    int i;\n    for (i = 0; i < max; ++i); // bug waiting to happen\n    if (i == j)\n        return i;\n\n##### Note\n\nAlways indenting the statement after `if (...)`, `for (...)`, and `while (...)` is usually a good idea:\n\n    if (i < 0) error(\"negative argument\");\n\n    if (i < 0)\n        error(\"negative argument\");\n\n##### Enforcement\n\nUse a tool.\n\n### <a name=\"rl-name-type\"></a>NL.5: Avoid encoding type information in names\n\n##### Rationale\n\nIf names reflect types rather than functionality, it becomes hard to change the types used to provide that functionality.\nAlso, if the type of a variable is changed, code using it will have to be modified.\nMinimize unintentional conversions.\n\n##### Example, bad\n\n    void print_int(int i);\n    void print_string(const char*);\n\n    print_int(1);          // repetitive, manual type matching\n    print_string(\"xyzzy\"); // repetitive, manual type matching\n\n##### Example, good\n\n    void print(int i);\n    void print(string_view);    // also works on any string-like sequence\n\n    print(1);              // clear, automatic type matching\n    print(\"xyzzy\");        // clear, automatic type matching\n\n##### Note\n\nNames with types encoded are either verbose or cryptic.\n\n    printS  // print a std::string\n    prints  // print a C-style string\n    printi  // print an int\n\nRequiring techniques like Hungarian notation to encode a type has been used in untyped languages, but is generally unnecessary and actively harmful in a strongly statically-typed language like C++, because the annotations get out of date (the warts are just like comments and rot just like them) and they interfere with good use of the language (use the same name and overload resolution instead).\n\n##### Note\n\nSome styles use very general (not type-specific) prefixes to denote the general use of a variable.\n\n    auto p = new User();\n    auto p = make_unique<User>();\n    // note: \"p\" is not being used to say \"raw pointer to type User,\"\n    //       just generally to say \"this is an indirection\"\n\n    auto cntHits = calc_total_of_hits(/*...*/);\n    // note: \"cnt\" is not being used to encode a type,\n    //       just generally to say \"this is a count of something\"\n\nThis is not harmful and does not fall under this guideline because it does not encode type information.\n\n##### Note\n\nSome styles distinguish members from local variable, and/or from global variable.\n\n    struct S {\n        int m_;\n        S(int m) : m_{abs(m)} { }\n    };\n\nThis is not harmful and does not fall under this guideline because it does not encode type information.\n\n##### Note\n\nLike C++, some styles distinguish types from non-types.\nFor example, by capitalizing type names, but not the names of functions and variables.\n\n    typename<typename T>\n    class HashTable {   // maps string to T\n        // ...\n    };\n\n    HashTable<int> index;\n\nThis is not harmful and does not fall under this guideline because it does not encode type information.\n\n### <a name=\"rl-name-length\"></a>NL.7: Make the length of a name roughly proportional to the length of its scope\n\n**Rationale**: The larger the scope the greater the chance of confusion and of an unintended name clash.\n\n##### Example\n\n    double sqrt(double x);   // return the square root of x; x must be non-negative\n\n    int length(const char* p);  // return the number of characters in a zero-terminated C-style string\n\n    int length_of_string(const char zero_terminated_array_of_char[])    // bad: verbose\n\n    int g;      // bad: global variable with a cryptic name\n\n    int open;   // bad: global variable with a short, popular name\n\nThe use of `p` for pointer and `x` for a floating-point variable is conventional and non-confusing in a restricted scope.\n\n##### Enforcement\n\n???\n\n### <a name=\"rl-name\"></a>NL.8: Use a consistent naming style\n\n**Rationale**: Consistency in naming and naming style increases readability.\n\n##### Note\n\nThere are many styles and when you use multiple libraries, you can't follow all their different conventions.\nChoose a \"house style\", but leave \"imported\" libraries with their original style.\n\n##### Example\n\nISO Standard, use lower case only and digits, separate words with underscores:\n\n* `int`\n* `vector`\n* `my_map`\n\nAvoid identifier names that contain double underscores `__` or that start with an underscore followed by a capital letter (e.g., `_Throws`).\nSuch identifiers are reserved for the C++ implementation.\n\n##### Example\n\n[Stroustrup](https://www.stroustrup.com/Programming/PPP-style.pdf):\nISO Standard, but with upper case used for your own types and concepts:\n\n* `int`\n* `vector`\n* `My_map`\n\n##### Example\n\nCamelCase: capitalize each word in a multi-word identifier:\n\n* `int`\n* `vector`\n* `MyMap`\n* `myMap`\n\nSome conventions capitalize the first letter, some don't.\n\n##### Note\n\nTry to be consistent in your use of acronyms and lengths of identifiers:\n\n    int mtbf {12};\n    int mean_time_between_failures {12}; // make up your mind\n\n##### Enforcement\n\nWould be possible except for the use of libraries with varying conventions.\n\n### <a name=\"rl-all-caps\"></a>NL.9: Use `ALL_CAPS` for macro names only\n\n##### Reason\n\nTo avoid confusing macros with names that obey scope and type rules.\n\n##### Example\n\n    void f()\n    {\n        const int SIZE{1000};  // Bad, use 'size' instead\n        int v[SIZE];\n    }\n\n##### Note\n\nIn particular, this avoids confusing macros with non-macro symbolic constants (see also [Enum.5: Don't use `ALL_CAPS` for enumerators](#renum-caps))\n\n    enum bad { BAD, WORSE, HORRIBLE }; // BAD\n\n##### Enforcement\n\n* Flag macros with lower-case letters\n* Flag `ALL_CAPS` non-macro names\n\n### <a name=\"rl-camel\"></a>NL.10: Prefer `underscore_style` names\n\n##### Reason\n\nThe use of underscores to separate parts of a name is the original C and C++ style and used in the C++ Standard Library.\n\n##### Note\n\nThis rule is a default to use only if you have a choice.\nOften, you don't have a choice and must follow an established style for [consistency](#rl-name).\nThe need for consistency beats personal taste.\n\nThis is a recommendation for [when you have no constraints or better ideas](#s-naming).\nThis rule was added after many requests for guidance.\n\n##### Example\n\n[Stroustrup](https://www.stroustrup.com/Programming/PPP-style.pdf):\nISO Standard, but with upper case used for your own types and concepts:\n\n* `int`\n* `vector`\n* `My_map`\n\n##### Enforcement\n\nImpossible.\n\n### <a name=\"rl-literals\"></a>NL.11: Make literals readable\n\n##### Reason\n\nReadability.\n\n##### Example\n\nUse digit separators to avoid long strings of digits\n\n    auto c = 299'792'458; // m/s2\n    auto q2 = 0b0000'1111'0000'0000;\n    auto ss_number = 123'456'7890;\n\n##### Example\n\nUse literal suffixes where clarification is needed\n\n    auto hello = \"Hello!\"s; // a std::string\n    auto world = \"world\";   // a C-style string\n    auto interval = 100ms;  // using <chrono>\n\n##### Note\n\nLiterals should not be sprinkled all over the code as [\"magic constants\"](#res-magic),\nbut it is still a good idea to make them readable where they are defined.\nIt is easy to make a typo in a long string of integers.\n\n##### Enforcement\n\nFlag long digit sequences. The trouble is to define \"long\"; maybe 7.\n\n### <a name=\"rl-space\"></a>NL.15: Use spaces sparingly\n\n##### Reason\n\nToo much space makes the text larger and distracts.\n\n##### Example, bad\n\n    #include < map >\n\n    int main(int argc, char * argv [ ])\n    {\n        // ...\n    }\n\n##### Example\n\n    #include <map>\n\n    int main(int argc, char* argv[])\n    {\n        // ...\n    }\n\n##### Note\n\nSome IDEs have their own opinions and add distracting space.\n\nThis is a recommendation for [when you have no constraints or better ideas](#s-naming).\nThis rule was added after many requests for guidance.\n\n##### Note\n\nWe value well-placed whitespace as a significant help for readability. Just don't overdo it.\n\n### <a name=\"rl-order\"></a>NL.16: Use a conventional class member declaration order\n\n##### Reason\n\nA conventional order of members improves readability.\n\nWhen declaring a class use the following order\n\n* types: classes, enums, and aliases (`using`)\n* constructors, assignments, destructor\n* functions\n* data\n\nUse the `public` before `protected` before `private` order.\n\nThis is a recommendation for [when you have no constraints or better ideas](#s-naming).\nThis rule was added after many requests for guidance.\n\n##### Example\n\n    class X {\n    public:\n        // interface\n    protected:\n        // unchecked function for use by derived class implementations\n    private:\n        // implementation details\n    };\n\n##### Example\n\nSometimes, the default order of members conflicts with a desire to separate the public interface from implementation details.\nIn such cases, private types and functions can be placed with private data.\n\n    class X {\n    public:\n        // interface\n    protected:\n        // unchecked function for use by derived class implementations\n    private:\n        // implementation details (types, functions, and data)\n    };\n\n##### Example, bad\n\nAvoid multiple blocks of declarations of one access (e.g., `public`) dispersed among blocks of declarations with different access (e.g. `private`).\n\n    class X {   // bad\n    public:\n        void f();\n    public:\n        int g();\n        // ...\n    };\n\nThe use of macros to declare groups of members often leads to violation of any ordering rules.\nHowever, using macros obscures what is being expressed anyway.\n\n##### Enforcement\n\nFlag departures from the suggested order. There will be a lot of old code that doesn't follow this rule.\n\n### <a name=\"rl-knr\"></a>NL.17: Use K&R-derived layout\n\n##### Reason\n\nThis is the original C and C++ layout. It preserves vertical space well. It distinguishes different language constructs (such as functions and classes) well.\n\n##### Note\n\nIn the context of C++, this style is often called \"Stroustrup\".\n\nThis is a recommendation for [when you have no constraints or better ideas](#s-naming).\nThis rule was added after many requests for guidance.\n\n##### Example\n\n    struct Cable {\n        int x;\n        // ...\n    };\n\n    double foo(int x)\n    {\n        if (0 < x) {\n            // ...\n        }\n\n        switch (x) {\n        case 0:\n            // ...\n            break;\n        case amazing:\n            // ...\n            break;\n        default:\n            // ...\n            break;\n        }\n\n        if (0 < x)\n            ++x;\n\n        if (x < 0)\n            something();\n        else\n            something_else();\n\n        return some_value;\n    }\n\nNote the space between `if` and `(`\n\n##### Note\n\nUse separate lines for each statement, the branches of an `if`, and the body of a `for`.\n\n##### Note\n\nThe `{` for a `class` and a `struct` is *not* on a separate line, but the `{` for a function is.\n\n##### Note\n\nCapitalize the names of your user-defined types to distinguish them from standards-library types.\n\n##### Note\n\nDo not capitalize function names.\n\n##### Enforcement\n\nIf you want enforcement, use an IDE to reformat.\n\n### <a name=\"rl-ptr\"></a>NL.18: Use C++-style declarator layout\n\n##### Reason\n\nThe C-style layout emphasizes use in expressions and grammar, whereas the C++-style emphasizes types.\nThe use in expressions argument doesn't hold for references.\n\n##### Example\n\n    T& operator[](size_t);   // OK\n    T &operator[](size_t);   // just strange\n    T & operator[](size_t);   // undecided\n\n##### Note\n\nThis is a recommendation for [when you have no constraints or better ideas](#s-naming).\nThis rule was added after many requests for guidance.\n\n##### Enforcement\n\nImpossible in the face of history.\n\n\n### <a name=\"rl-misread\"></a>NL.19: Avoid names that are easily misread\n\n##### Reason\n\nReadability.\nNot everyone has screens and printers that make it easy to distinguish all characters.\nWe easily confuse similarly spelled and slightly misspelled words.\n\n##### Example\n\n    int oO01lL = 6; // bad\n\n    int splunk = 7;\n    int splonk = 8; // bad: splunk and splonk are easily confused\n\n##### Enforcement\n\n???\n\n### <a name=\"rl-stmt\"></a>NL.20: Don't place two statements on the same line\n\n##### Reason\n\nReadability.\nIt is really easy to overlook a statement when there is more on a line.\n\n##### Example\n\n    int x = 7; char* p = 29;    // don't\n    int x = 7; f(x);  ++x;      // don't\n\n##### Enforcement\n\nEasy.\n\n### <a name=\"rl-dcl\"></a>NL.21: Declare one name (only) per declaration\n\n##### Reason\n\nReadability.\nMinimizing confusion with the declarator syntax.\n\n##### Note\n\nFor details, see [ES.10](#res-name-one).\n\n\n### <a name=\"rl-void\"></a>NL.25: Don't use `void` as an argument type\n\n##### Reason\n\nIt's verbose and only needed where C compatibility matters.\n\n##### Example\n\n    void f(void);   // bad\n\n    void g();       // better\n\n##### Note\n\nEven Dennis Ritchie deemed `void f(void)` an abomination.\nYou can make an argument for that abomination in C when function prototypes were rare so that banning:\n\n    int f();\n    f(1, 2, \"weird but valid C89\");   // hope that f() is defined int f(a, b, c) char* c; { /* ... */ }\n\nwould have caused major problems, but not in the 21st century and in C++.\n\n### <a name=\"rl-const\"></a>NL.26: Use conventional `const` notation\n\n##### Reason\n\nConventional notation is more familiar to more programmers.\nConsistency in large code bases.\n\n##### Example\n\n    const int x = 7;    // OK\n    int const y = 9;    // bad\n\n    const int *const p = nullptr;   // OK, constant pointer to constant int\n    int const *const p = nullptr;   // bad, constant pointer to constant int\n\n##### Note\n\nWe are well aware that you could claim the \"bad\" examples are more logical than the ones marked \"OK\",\nbut they also confuse more people, especially novices relying on teaching material using the far more common, conventional OK style.\n\nAs ever, remember that the aim of these naming and layout rules is consistency and that aesthetics vary immensely.\n\nThis is a recommendation for [when you have no constraints or better ideas](#s-naming).\nThis rule was added after many requests for guidance.\n\n##### Enforcement\n\nFlag `const` used as a suffix for a type.\n\n### <a name=\"rl-file-suffix\"></a>NL.27: Use a `.cpp` suffix for code files and `.h` for interface files\n\n##### Reason\n\nIt's a longstanding convention.\nBut consistency is more important, so if your project uses something else, follow that.\n\n##### Note\n\nThis convention reflects a common use pattern:\nHeaders are more often shared with C to compile as both C++ and C, which typically uses `.h`,\nand it's easier to name all headers `.h` instead of having different extensions for just those headers that are intended to be shared with C.\nOn the other hand, implementation files are rarely shared with C and so should typically be distinguished from `.c` files,\nso it's normally best to name all C++ implementation files something else (such as `.cpp`).\n\nThe specific names `.h` and `.cpp` are not required (just recommended as a default) and other names are in widespread use.\nExamples are `.hh`, `.C`, and `.cxx`. Use such names equivalently.\nIn this document, we refer to `.h` and `.cpp` as a shorthand for header and implementation files,\neven though the actual extension might be different.\n\nYour IDE (if you use one) might have strong opinions about suffixes.\n\n##### Example\n\n    // foo.h:\n    extern int a;   // a declaration\n    extern void foo();\n\n    // foo.cpp:\n    int a;   // a definition\n    void foo() { ++a; }\n\n`foo.h` provides the interface to `foo.cpp`. Global variables are best avoided.\n\n##### Example, bad\n\n    // foo.h:\n    int a;   // a definition\n    void foo() { ++a; }\n\n`#include <foo.h>` twice in a program and you get a linker error for two one-definition-rule violations.\n\n##### Enforcement\n\n* Flag non-conventional file names.\n* Check that `.h` and `.cpp` (and equivalents) follow the rules below.\n\n# <a name=\"s-faq\"></a>FAQ: Answers to frequently asked questions\n\nThis section covers answers to frequently asked questions about these guidelines.\n\n### <a name=\"faq-aims\"></a>FAQ.1: What do these guidelines aim to achieve?\n\nSee the <a href=\"#s-abstract\">top of this page</a>. This is an open-source project to maintain modern authoritative guidelines for writing C++ code using the current C++ Standard. The guidelines are designed to be modern, machine-enforceable wherever possible, and open to contributions and forking so that organizations can easily incorporate them into their own corporate coding guidelines.\n\n### <a name=\"faq-announced\"></a>FAQ.2: When and where was this work first announced?\n\nIt was announced by [Bjarne Stroustrup in his CppCon 2015 opening keynote, \"Writing Good C++14\"](https://isocpp.org/blog/2015/09/stroustrup-cppcon15-keynote). See also the [accompanying isocpp.org blog post](https://isocpp.org/blog/2015/09/bjarne-stroustrup-announces-cpp-core-guidelines), and for the rationale of the type and memory safety guidelines see [Herb Sutter's follow-up CppCon 2015 talk, \"Writing Good C++14 ... By Default\"](https://isocpp.org/blog/2015/09/sutter-cppcon15-day2plenary).\n\n### <a name=\"faq-maintainers\"></a>FAQ.3: Who are the authors and maintainers of these guidelines?\n\nThe initial primary authors and maintainers are Bjarne Stroustrup and Herb Sutter, and the guidelines so far were developed with contributions from experts at CERN, Microsoft, Morgan Stanley, and several other organizations. At the time of their release, the guidelines are in a \"0.6\" state, and contributions are welcome. As Stroustrup said in his announcement: \"We need help!\"\n\n### <a name=\"faq-contribute\"></a>FAQ.4: How can I contribute?\n\nSee [CONTRIBUTING.md](https://github.com/isocpp/CppCoreGuidelines/blob/master/CONTRIBUTING.md). We appreciate volunteer help!\n\n### <a name=\"faq-maintainer\"></a>FAQ.5: How can I become an editor/maintainer?\n\nBy contributing a lot first and having the consistent quality of your contributions recognized. See [CONTRIBUTING.md](https://github.com/isocpp/CppCoreGuidelines/blob/master/CONTRIBUTING.md). We appreciate volunteer help!\n\n### <a name=\"faq-iso\"></a>FAQ.6: Have these guidelines been approved by the ISO C++ standards committee? Do they represent the consensus of the committee?\n\nNo. These guidelines are outside the standard. They are intended to serve the standard, and be maintained as current guidelines about how to use the current Standard C++ effectively. We aim to keep them in sync with the standard as that is evolved by the committee.\n\n### <a name=\"faq-isocpp\"></a>FAQ.7: If these guidelines are not approved by the committee, why are they under `github.com/isocpp`?\n\nBecause `isocpp` is the Standard C++ Foundation; the committee's repositories are under [github.com/*cplusplus*](https://github.com/cplusplus). Some neutral organization has to own the copyright and license to make it clear this is not being dominated by any one person or vendor. The natural entity is the Foundation, which exists to promote the use and up-to-date understanding of modern Standard C++ and the work of the committee. This follows the same pattern that isocpp.org did for the [C++ FAQ](https://isocpp.org/faq), which was initially the work of Bjarne Stroustrup, Marshall Cline, and Herb Sutter and contributed to the open project in the same way.\n\n### <a name=\"faq-cpp98\"></a>FAQ.8: Will there be a C++98 version of these Guidelines? A C++11 version?\n\nNo. These guidelines are about how to best use modern standard C++ and write code assuming you have a modern conforming compiler.\n\n### <a name=\"faq-language-extensions\"></a>FAQ.9: Do these guidelines propose new language features?\n\nNo. These guidelines are about how to best use modern Standard C++, and they limit themselves to recommending only those features.\n\n### <a name=\"faq-markdown\"></a>FAQ.10: What version of Markdown do these guidelines use?\n\nThese coding standards are written using [CommonMark](https://commonmark.org), and `<a>` HTML anchors.\n\nWe are considering the following extensions from [GitHub Flavored Markdown (GFM)](https://help.github.com/articles/github-flavored-markdown/):\n\n* fenced code blocks (consistently using indented vs. fenced is under discussion)\n* tables (none yet but we'll likely need them, and this is a GFM extension)\n\nAvoid other HTML tags and other extensions.\n\nNote: We are not yet consistent with this style.\n\n### <a name=\"faq-gsl\"></a>FAQ.50: What is the GSL (guidelines support library)?\n\nThe GSL is the small set of types and aliases specified in these guidelines. As of this writing, their specification herein is too sparse; we plan to add a WG21-style interface specification to ensure that different implementations agree, and to propose as a contribution for possible standardization, subject as usual to whatever the committee decides to accept/improve/alter/reject.\n\n### <a name=\"faq-msgsl\"></a>FAQ.51: Is [github.com/Microsoft/GSL](https://github.com/Microsoft/GSL) the GSL?\n\nNo. That is just a first implementation contributed by Microsoft. Other implementations by other vendors are encouraged, as are forks of and contributions to that implementation. As of this writing one week into the public project, at least one GPLv3 open-source implementation already exists. We plan to produce a WG21-style interface specification to ensure that different implementations agree.\n\n### <a name=\"faq-gsl-implementation\"></a>FAQ.52: Why not supply an actual GSL implementation in/with these guidelines?\n\nWe are reluctant to bless one particular implementation because we do not want to make people think there is only one, and inadvertently stifle parallel implementations. And if these guidelines included an actual implementation, then whoever contributed it could be mistakenly seen as too influential. We prefer to follow the long-standing approach of the committee, namely to specify interfaces, not implementations. But at the same time we want at least one implementation available; we hope for many.\n\n### <a name=\"faq-boost\"></a>FAQ.53: Why weren't the GSL types proposed through Boost?\n\nBecause we want to use them immediately, and because they are temporary in that we want to retire them as soon as types that fill the same needs exist in the standard library.\n\n### <a name=\"faq-gsl-iso\"></a>FAQ.54: Has the GSL (guidelines support library) been approved by the ISO C++ standards committee?\n\nNo. The GSL exists only to supply a few types and aliases that are not currently in the standard library. If the committee decides on standardized versions (of these or other types that fill the same need) then they can be removed from the GSL.\n\n### <a name=\"faq-gsl-string-view\"></a>FAQ.55: If you're using the standard types where available, why is the GSL `span<char>` different from the `string_view` in the Library Fundamentals 1 Technical Specification and C++17 Working Paper? Why not just use the committee-approved `string_view`?\n\nThe consensus on the taxonomy of views for the C++ Standard Library was that \"view\" means \"read-only\", and \"span\" means \"read/write\". If you only need a read-only view of characters that does not need guaranteed bounds-checking and you have C++17, use C++17 `std::string_view`. Otherwise, if you need a read-write view that does not need guaranteed bounds-checking and you have C++20, use C++20 `std::span<char>`. Otherwise, use `gsl::span<char>`.\n\n### <a name=\"faq-gsl-owner\"></a>FAQ.56: Is `owner` the same as the proposed `observer_ptr`?\n\nNo. `owner` owns, is an alias, and can be applied to any indirection type. The main intent of `observer_ptr` is to signify a *non*-owning pointer.\n\n### <a name=\"faq-gsl-stack-array\"></a>FAQ.57: Is `stack_array` the same as the standard `array`?\n\nNo. `stack_array` is guaranteed to be allocated on the stack. Although a `std::array` contains its storage directly inside itself, the `array` object can be put anywhere, including the heap.\n\n### <a name=\"faq-gsl-dyn-array\"></a>FAQ.58: Is `dyn_array` the same as `vector` or the proposed `dynarray`?\n\nNo. `dyn_array` is a container, like `vector`, but it is not resizable; its size is fixed at runtime when it is constructed.\nIt is a safe way to refer to a dynamically \"heap\"-allocated fixed-size array. Unlike `vector`, it is intended to replace array-`new[]`. Unlike the `dynarray` that has been proposed in the committee, this does not anticipate compiler/language magic to somehow allocate it on the stack when it is a member of an object that is allocated on the stack; it simply refers to a \"dynamic\" or heap-based array.\n\n### <a name=\"faq-gsl-expects\"></a>FAQ.59: Is `Expects` the same as `assert`?\n\nNo. It is a placeholder for language support for contract preconditions.\n\n### <a name=\"faq-gsl-ensures\"></a>FAQ.60: Is `Ensures` the same as `assert`?\n\nNo. It is a placeholder for language support for contract postconditions.\n\n# <a name=\"s-libraries\"></a>Appendix A: Libraries\n\nThis section lists recommended libraries, and explicitly recommends a few.\n\n??? Suitable for the general guide? I think not ???\n\n# <a name=\"s-modernizing\"></a>Appendix B: Modernizing code\n\nIdeally, we follow all rules in all code.\nRealistically, we have to deal with a lot of old code:\n\n* application code written before the guidelines were formulated or known\n* libraries written to older/different standards\n* code written under \"unusual\" constraints\n* code that we just haven't gotten around to modernizing\n\nIf we have a million lines of new code, the idea of \"just changing it all at once\" is typically unrealistic.\nThus, we need a way of gradually modernizing a code base.\n\nUpgrading older code to modern style can be a daunting task.\nOften, the old code is both a mess (hard to understand) and working correctly (for the current range of uses).\nTypically, the original programmer is not around and the test cases incomplete.\nThe fact that the code is a mess dramatically increases the effort needed to make any change and the risk of introducing errors.\nOften, messy old code runs unnecessarily slowly because it requires outdated compilers and cannot take advantage of modern hardware.\nIn many cases, automated \"modernizer\"-style tool support would be required for major upgrade efforts.\n\nThe purpose of modernizing code is to simplify adding new functionality, to ease maintenance, and to increase performance (throughput or latency), and to better utilize modern hardware.\nMaking code \"look pretty\" or \"follow modern style\" are not by themselves reasons for change.\nThere are risks implied by every change and costs (including the cost of lost opportunities) implied by having an outdated code base.\nThe cost reductions must outweigh the risks.\n\nBut how?\n\nThere is no one approach to modernizing code.\nHow best to do it depends on the code, the pressure for updates, the backgrounds of the developers, and the available tool.\nHere are some (very general) ideas:\n\n* The ideal is \"just upgrade everything.\" That gives the most benefits for the shortest total time.\n  In most circumstances, it is also impossible.\n* We could convert a code base module for module, but any rules that affects interfaces (especially ABIs), such as [use `span`](#ss-views), cannot be done on a per-module basis.\n* We could convert code \"bottom up\" starting with the rules we estimate will give the greatest benefits and/or the least trouble in a given code base.\n* We could start by focusing on the interfaces, e.g., make sure that no resources are lost and no pointer is misused.\n  This would be a set of changes across the whole code base, but would most likely have huge benefits.\n  Afterwards, code hidden behind those interfaces can be gradually modernized without affecting other code.\n\nWhichever way you choose, please note that the most advantages come with the highest conformance to the guidelines.\nThe guidelines are not a random set of unrelated rules where you can randomly pick and choose with an expectation of success.\n\nWe would dearly love to hear about experience and about tools used.\nModernization can be much faster, simpler, and safer when supported with analysis tools and even code transformation tools.\n\n# <a name=\"s-discussion\"></a>Appendix C: Discussion\n\nThis section contains follow-up material on rules and sets of rules.\nIn particular, here we present further rationale, longer examples, and discussions of alternatives.\n\n### <a name=\"sd-order\"></a>Discussion: Define and initialize data members in the order of member declaration\n\nData members are always initialized in the order they are declared in the class definition, so write them in that order in the constructor initialization list. Writing them in a different order just makes the code confusing because it won't run in the order you see, and that can make it hard to see order-dependent bugs.\n\n    class Employee {\n        string email, first, last;\n    public:\n        Employee(const char* firstName, const char* lastName);\n        // ...\n    };\n\n    Employee::Employee(const char* firstName, const char* lastName)\n      : first(firstName),\n        last(lastName),\n        // BAD: first and last not yet constructed\n        email(first + \".\" + last + \"@acme.com\")\n    {}\n\nIn this example, `email` will be constructed before `first` and `last` because it is declared first. That means its constructor will attempt to use `first` and `last` too soon -- not just before they are set to the desired values, but before they are constructed at all.\n\nIf the class definition and the constructor body are in separate files, the long-distance influence that the order of data member declarations has over the constructor's correctness will be even harder to spot.\n\n**References**:\n\n[\\[Cline99\\]](#Cline99) §22.03-11, [\\[Dewhurst03\\]](#Dewhurst03) §52-53, [\\[Koenig97\\]](#Koenig97) §4, [\\[Lakos96\\]](#Lakos96) §10.3.5, [\\[Meyers97\\]](#Meyers97) §13, [\\[Murray93\\]](#Murray93) §2.1.3, [\\[Sutter00\\]](#Sutter00) §47\n\n### <a name=\"sd-init\"></a>Discussion: Use of `=`, `{}`, and `()` as initializers\n\n???\n\n### <a name=\"sd-factory\"></a>Discussion: Use a factory function if you need \"virtual behavior\" during initialization\n\nIf your design wants virtual dispatch into a derived class from a base class constructor or destructor for functions like `f` and `g`, you need other techniques, such as a post-constructor -- a separate member function the caller must invoke to complete initialization, which can safely call `f` and `g` because in member functions virtual calls behave normally. Some techniques for this are shown in the References. Here's a non-exhaustive list of options:\n\n* *Pass the buck:* Just document that user code must call the post-initialization function right after constructing an object.\n* *Post-initialize lazily:* Do it during the first call of a member function. A Boolean flag in the base class tells whether or not post-construction has taken place yet.\n* *Use virtual base class semantics:* Language rules dictate that the constructor of the most-derived class decides which base constructor will be invoked; you can use that to your advantage. (See [\\[Taligent94\\]](#Taligent94).)\n* *Use a factory function:* This way, you can easily force a mandatory invocation of a post-constructor function.\n\nHere is an example of the last option:\n\n    class B {\n    public:\n        B()\n        {\n            /* ... */\n            f(); // BAD: C.82: Don't call virtual functions in constructors and destructors\n            /* ... */\n        }\n\n        virtual void f() = 0;\n    };\n\n    class B {\n    protected:\n        class Token {};\n\n    public:\n        // constructor needs to be public so that make_shared can access it.\n        // protected access level is gained by requiring a Token.\n        explicit B(Token) { /* ... */ }  // create an imperfectly initialized object\n        virtual void f() = 0;\n\n        template<class T>\n        static shared_ptr<T> create()    // interface for creating shared objects\n        {\n            auto p = make_shared<T>(typename T::Token{});\n            p->post_initialize();\n            return p;\n        }\n\n    protected:\n        virtual void post_initialize()   // called right after construction\n            { /* ... */ f(); /* ... */ } // GOOD: virtual dispatch is safe\n        }\n    };\n\n\n    class D : public B {                 // some derived class\n    protected:\n        class Token {};\n\n    public:\n        // constructor needs to be public so that make_shared can access it.\n        // protected access level is gained by requiring a Token.\n        explicit D(Token) : B{ B::Token{} } {}\n        void f() override { /* ...  */ };\n\n    protected:\n        template<class T>\n        friend shared_ptr<T> B::create();\n    };\n\n    shared_ptr<D> p = D::create<D>();    // creating a D object\n\nThis design requires the following discipline:\n\n* Derived classes such as `D` must not expose a publicly callable constructor. Otherwise, `D`'s users could create `D` objects that don't invoke `post_initialize`.\n* Allocation is limited to `operator new`. `B` can, however, override `new` (see Items 45 and 46 in [SuttAlex05](#SuttAlex05)).\n* `D` must define a constructor with the same parameters that `B` selected. Defining several overloads of `create` can assuage this problem, however; and the overloads can even be templated on the argument types.\n\nIf the requirements above are met, the design guarantees that `post_initialize` has been called for any fully constructed `B`-derived object. `post_initialize` doesn't need to be virtual; it can, however, invoke virtual functions freely.\n\nIn summary, no post-construction technique is perfect. The worst techniques dodge the whole issue by simply asking the caller to invoke the post-constructor manually. Even the best require a different syntax for constructing objects (easy to check at compile time) and/or cooperation from derived class authors (impossible to check at compile time).\n\n**References**: [\\[Alexandrescu01\\]](#Alexandrescu01) §3, [\\[Boost\\]](#Boost), [\\[Dewhurst03\\]](#Dewhurst03) §75, [\\[Meyers97\\]](#Meyers97) §46, [\\[Stroustrup00\\]](#Stroustrup00) §15.4.3, [\\[Taligent94\\]](#Taligent94)\n\n### <a name=\"sd-dtor\"></a>Discussion: Make base class destructors public and virtual, or protected and non-virtual\n\nShould destruction behave virtually? That is, should destruction through a pointer to a `base` class be allowed? If yes, then `base`'s destructor must be public in order to be callable, and virtual, otherwise calling it results in undefined behavior. Otherwise, it should be protected so that only derived classes can invoke it in their own destructors, and non-virtual since it doesn't need to behave virtually.\n\n##### Example\n\nThe common case for a base class is that it's intended to have publicly derived classes, and so calling code is just about sure to use something like a `shared_ptr<base>`:\n\n    class Base {\n    public:\n        ~Base();                   // BAD, not virtual\n        virtual ~Base();           // GOOD\n        // ...\n    };\n\n    class Derived : public Base { /* ... */ };\n\n    {\n        unique_ptr<Base> pb = make_unique<Derived>();\n        // ...\n    } // ~pb invokes correct destructor only when ~Base is virtual\n\nIn rarer cases, such as policy classes, the class is used as a base class for convenience, not for polymorphic behavior. It is recommended to make those destructors protected and non-virtual:\n\n    class My_policy {\n    public:\n        virtual ~My_policy();      // BAD, public and virtual\n    protected:\n        ~My_policy();              // GOOD\n        // ...\n    };\n\n    template<class Policy>\n    class customizable : Policy { /* ... */ }; // note: private inheritance\n\n##### Note\n\nThis simple guideline illustrates a subtle issue and reflects modern uses of inheritance and object-oriented design principles.\n\nFor a base class `Base`, calling code might try to destroy derived objects through pointers to `Base`, such as when using a `unique_ptr<Base>`. If `Base`'s destructor is public and non-virtual (the default), it can be accidentally called on a pointer that actually points to a derived object, in which case the behavior of the attempted deletion is undefined. This state of affairs has led older coding standards to impose a blanket requirement that all base class destructors must be virtual. This is overkill (even if it is the common case); instead, the rule should be to make base class destructors virtual if and only if they are public.\n\nTo write a base class is to define an abstraction (see Items 35 through 37). Recall that for each member function participating in that abstraction, you need to decide:\n\n* Whether it should behave virtually or not.\n* Whether it should be publicly available to all callers using a pointer to `Base` or else be a hidden internal implementation detail.\n\nAs described in Item 39, for a normal member function, the choice is between allowing it to be called via a pointer to `Base` non-virtually (but possibly with virtual behavior if it invokes virtual functions, such as in the NVI or Template Method patterns), virtually, or not at all. The NVI pattern is a technique to avoid public virtual functions.\n\nDestruction can be viewed as just another operation, albeit with special semantics that make non-virtual calls dangerous or wrong. For a base class destructor, therefore, the choice is between allowing it to be called via a pointer to `Base` virtually or not at all; \"non-virtually\" is not an option. Hence, a base class destructor is virtual if it can be called (i.e., is public), and non-virtual otherwise.\n\nNote that the NVI pattern cannot be applied to the destructor because constructors and destructors cannot make deep virtual calls. (See Items 39 and 55.)\n\nCorollary: When writing a base class, always write a destructor explicitly, because the implicitly generated one is public and non-virtual. You can always `=default` the implementation if the default body is fine and you're just writing the function to give it the proper visibility and virtuality.\n\n##### Exception\n\nSome component architectures (e.g., COM and CORBA) don't use a standard deletion mechanism, and foster different protocols for object disposal. Follow the local patterns and idioms, and adapt this guideline as appropriate.\n\nConsider also this rare case:\n\n* `B` is both a base class and a concrete class that can be instantiated by itself, and so the destructor must be public for `B` objects to be created and destroyed.\n* Yet `B` also has no virtual functions and is not meant to be used polymorphically, and so although the destructor is public it does not need to be virtual.\n\nThen, even though the destructor has to be public, there can be great pressure to not make it virtual because as the first virtual function it would incur all the run-time type overhead when the added functionality should never be needed.\n\nIn this rare case, you could make the destructor public and non-virtual but clearly document that further-derived objects must not be used polymorphically as `B`'s. This is what was done with `std::unary_function`.\n\nIn general, however, avoid concrete base classes (see Item 35). For example, `unary_function` is a bundle-of-typedefs that was never intended to be instantiated standalone. It really makes no sense to give it a public destructor; a better design would be to follow this Item's advice and give it a protected non-virtual destructor.\n\n**References**: [\\[SuttAlex05\\]](#SuttAlex05) Item 50, [\\[Cargill92\\]](#Cargill92) pp. 77-79, 207, [\\[Cline99\\]](#Cline99) §21.06, 21.12-13, [\\[Henricson97\\]](#Henricson97) pp. 110-114, [\\[Koenig97\\]](#Koenig97) Chapters 4, 11, [\\[Meyers97\\]](#Meyers97) §14, [\\[Stroustrup00\\]](#Stroustrup00) §12.4.2, [\\[Sutter02\\]](#Sutter02) §27, [\\[Sutter04\\]](#Sutter04) §18\n\n### <a name=\"sd-noexcept\"></a>Discussion: Usage of noexcept\n\n???\n\n### <a name=\"sd-never-fail\"></a>Discussion: Destructors, deallocation, and swap must never fail\n\nNever allow an error to be reported from a destructor, a resource deallocation function (e.g., `operator delete`), or a `swap` function using `throw`. It is nearly impossible to write useful code if these operations can fail, and even if something does go wrong it nearly never makes any sense to retry. Specifically, types whose destructors might throw an exception are flatly forbidden from use with the C++ Standard Library. Most destructors are now implicitly `noexcept` by default.\n\n##### Example\n\n    class Nefarious {\n    public:\n        Nefarious() { /* code that could throw */ }    // ok\n        ~Nefarious() { /* code that could throw */ }   // BAD, should not throw\n        // ...\n    };\n\n1. `Nefarious` objects are hard to use safely even as local variables:\n\n\n        void test(string& s)\n        {\n            Nefarious n;          // trouble brewing\n            string copy = s;      // copy the string\n        } // destroy copy and then n\n\n    Here, copying `s` could throw, and if that throws and if `n`'s destructor then also throws, the program will exit via `std::terminate` because two exceptions can't be propagated simultaneously.\n\n2. Classes with `Nefarious` members or bases are also hard to use safely, because their destructors must invoke `Nefarious`' destructor, and are similarly poisoned by its bad behavior:\n\n\n        class Innocent_bystander {\n            Nefarious member;     // oops, poisons the enclosing class's destructor\n            // ...\n        };\n\n        void test(string& s)\n        {\n            Innocent_bystander i;  // more trouble brewing\n            string copy2 = s;      // copy the string\n        } // destroy copy and then i\n\n    Here, if constructing `copy2` throws, we have the same problem because `i`'s destructor now also can throw, and if so we'll invoke `std::terminate`.\n\n3. You can't reliably create global or static `Nefarious` objects either:\n\n\n        static Nefarious n;       // oops, any destructor exception can't be caught\n\n4. You can't reliably create arrays of `Nefarious`:\n\n\n        void test()\n        {\n            std::array<Nefarious, 10> arr; // this line can std::terminate()\n        }\n\n    The behavior of arrays is undefined in the presence of destructors that throw because there is no reasonable rollback behavior that could ever be devised. Just think: What code can the compiler generate for constructing an `arr` where, if the fourth object's constructor throws, the code has to give up and in its cleanup mode tries to call the destructors of the already-constructed objects ... and one or more of those destructors throws? There is no satisfactory answer.\n\n5. You can't use `Nefarious` objects in standard containers:\n\n\n        std::vector<Nefarious> vec(10);   // this line can std::terminate()\n\n    The standard library forbids all destructors used with it from throwing. You can't store `Nefarious` objects in standard containers or use them with any other part of the standard library.\n\n##### Note\n\nThese are key functions that must not fail because they are necessary for the two key operations in transactional programming: to back out work if problems are encountered during processing, and to commit work if no problems occur. If there's no way to safely back out using no-fail operations, then no-fail rollback is impossible to implement. If there's no way to safely commit state changes using a no-fail operation (notably, but not limited to, `swap`), then no-fail commit is impossible to implement.\n\nConsider the following advice and requirements found in the C++ Standard:\n\n> If a destructor called during stack unwinding exits with an exception, terminate is called (15.5.1). So destructors should generally catch exceptions and not let them propagate out of the destructor. --[\\[C++03\\]](#Cplusplus03) §15.2(3)\n>\n> No destructor operation defined in the C++ Standard Library (including the destructor of any type that is used to instantiate a standard-library template) will throw an exception. --[\\[C++03\\]](#Cplusplus03) §17.4.4.8(3)\n\nDeallocation functions, including specifically overloaded `operator delete` and `operator delete[]`, fall into the same category, because they too are used during cleanup in general, and during exception handling in particular, to back out of partial work that needs to be undone.\nBesides destructors and deallocation functions, common error-safety techniques rely also on `swap` operations never failing -- in this case, not because they are used to implement a guaranteed rollback, but because they are used to implement a guaranteed commit. For example, here is an idiomatic implementation of `operator=` for a type `T` that performs copy construction followed by a call to a no-fail `swap`:\n\n    T& T::operator=(const T& other)\n    {\n        auto temp = other;\n        swap(temp);\n        return *this;\n    }\n\n(See also Item 56. ???)\n\nFortunately, when releasing a resource, the scope for failure is definitely smaller. If using exceptions as the error reporting mechanism, make sure such functions handle all exceptions and other errors that their internal processing might generate. (For exceptions, simply wrap everything sensitive that your destructor does in a `try/catch(...)` block.) This is particularly important because a destructor might be called in a crisis situation, such as failure to allocate a system resource (e.g., memory, files, locks, ports, windows, or other system objects).\n\nWhen using exceptions as your error handling mechanism, always document this behavior by declaring these functions `noexcept`. (See Item 75.)\n\n**References**: [\\[SuttAlex05\\]](#SuttAlex05) Item 51; [\\[C++03\\]](#Cplusplus03) §15.2(3), §17.4.4.8(3), [\\[Meyers96\\]](#Meyers96) §11, [\\[Stroustrup00\\]](#Stroustrup00) §14.4.7, §E.2-4, [\\[Sutter00\\]](#Sutter00) §8, §16, [\\[Sutter02\\]](#Sutter02) §18-19\n\n## <a name=\"sd-consistent\"></a>Define Copy, move, and destroy consistently\n\n##### Reason\n\n ???\n\n##### Note\n\nIf you define a copy constructor, you must also define a copy assignment operator.\n\n##### Note\n\nIf you define a move constructor, you must also define a move assignment operator.\n\n##### Example\n\n    class X {\n    public:\n        X(const X&) { /* stuff */ }\n\n        // BAD: failed to also define a copy assignment operator\n\n        X(x&&) noexcept { /* stuff */ }\n\n        // BAD: failed to also define a move assignment operator\n\n        // ...\n    };\n\n    X x1;\n    X x2 = x1; // ok\n    x2 = x1;   // pitfall: either fails to compile, or does something suspicious\n\nIf you define a destructor, you should not use the compiler-generated copy or move operation; you probably need to define or suppress copy and/or move.\n\n    class X {\n        HANDLE hnd;\n        // ...\n    public:\n        ~X() { /* custom stuff, such as closing hnd */ }\n        // suspicious: no mention of copying or moving -- what happens to hnd?\n    };\n\n    X x1;\n    X x2 = x1; // pitfall: either fails to compile, or does something suspicious\n    x2 = x1;   // pitfall: either fails to compile, or does something suspicious\n\nIf you define copying, and any base or member has a type that defines a move operation, you should also define a move operation.\n\n    class X {\n        string s; // defines more efficient move operations\n        // ... other data members ...\n    public:\n        X(const X&) { /* stuff */ }\n        X& operator=(const X&) { /* stuff */ }\n\n        // BAD: failed to also define a move construction and move assignment\n        // (why wasn't the custom \"stuff\" repeated here?)\n    };\n\n    X test()\n    {\n        X local;\n        // ...\n        return local;  // pitfall: will be inefficient and/or do the wrong thing\n    }\n\nIf you define any of the copy constructor, copy assignment operator, or destructor, you probably should define the others.\n\n##### Note\n\nIf you need to define any of these five functions, it means you need it to do more than its default behavior -- and the five are asymmetrically interrelated. Here's how:\n\n* If you write/disable either of the copy constructor or the copy assignment operator, you probably need to do the same for the other: If one does \"special\" work, probably so should the other because the two functions should have similar effects. (See Item 53, which expands on this point in isolation.)\n* If you explicitly write the copying functions, you probably need to write the destructor: If the \"special\" work in the copy constructor is to allocate or duplicate some resource (e.g., memory, file, socket), you need to deallocate it in the destructor.\n* If you explicitly write the destructor, you probably need to explicitly write or disable copying: If you have to write a non-trivial destructor, it's often because you need to manually release a resource that the object held. If so, it is likely that those resources require careful duplication, and then you need to pay attention to the way objects are copied and assigned, or disable copying completely.\n\nIn many cases, holding properly encapsulated resources using RAII \"owning\" objects can eliminate the need to write these operations yourself. (See Item 13.)\n\nPrefer compiler-generated (including `=default`) special members; only these can be classified as \"trivial\", and at least one major standard library vendor heavily optimizes for classes having trivial special members. This is likely to become common practice.\n\n**Exceptions**: When any of the special functions are declared only to make them non-public or virtual, but without special semantics, it doesn't imply that the others are needed.\nIn rare cases, classes that have members of strange types (such as reference members) are an exception because they have peculiar copy semantics.\nIn a class holding a reference, you likely need to write the copy constructor and the assignment operator, but the default destructor already does the right thing. (Note that using a reference member is almost always wrong.)\n\n**References**: [\\[SuttAlex05\\]](#SuttAlex05) Item 52; [\\[Cline99\\]](#Cline99) §30.01-14, [\\[Koenig97\\]](#Koenig97) §4, [\\[Stroustrup00\\]](#Stroustrup00) §5.5, §10.4, [\\[SuttHysl04b\\]](#SuttHysl04b)\n\nResource management rule summary:\n\n* [Provide strong resource safety; that is, never leak anything that you think of as a resource](#cr-safety)\n* [Never return or throw while holding a resource not owned by a handle](#cr-never)\n* [A \"raw\" pointer or reference is never a resource handle](#cr-raw)\n* [Never let a pointer outlive the object it points to](#cr-outlive)\n* [Use templates to express containers (and other resource handles)](#cr-templates)\n* [Return containers by value (relying on move or copy elision for efficiency)](#cr-value-return)\n* [If a class is a resource handle, it needs a constructor, a destructor, and copy and/or move operations](#cr-handle)\n* [If a class is a container, give it an initializer-list constructor](#cr-list)\n\n### <a name=\"cr-safety\"></a>Discussion: Provide strong resource safety; that is, never leak anything that you think of as a resource\n\n##### Reason\n\nPrevent leaks. Leaks can lead to performance degradation, mysterious error, system crashes, and security violations.\n\n**Alternative formulation**: Have every resource represented as an object of some class managing its lifetime.\n\n##### Example\n\n    template<class T>\n    class Vector {\n    private:\n        T* elem;   // sz elements on the free store, owned by the class object\n        int sz;\n        // ...\n    };\n\nThis class is a resource handle. It manages the lifetime of the `T`s. To do so, `Vector` must define or delete [the copy, move, and destruction operations](#rc-five).\n\n##### Example\n\n    ??? \"odd\" non-memory resource ???\n\n##### Enforcement\n\nThe basic technique for preventing leaks is to have every resource owned by a resource handle with a suitable destructor. A checker can find \"naked `new`s\". Given a list of C-style allocation functions (e.g., `fopen()`), a checker can also find uses that are not managed by a resource handle. In general, \"naked pointers\" can be viewed with suspicion, flagged, and/or analyzed. A complete list of resources cannot be generated without human input (the definition of \"a resource\" is necessarily too general), but a tool can be \"parameterized\" with a resource list.\n\n### <a name=\"cr-never\"></a>Discussion: Never return or throw while holding a resource not owned by a handle\n\n##### Reason\n\nThat would be a leak.\n\n##### Example\n\n    void f(int i)\n    {\n        FILE* f = fopen(\"a file\", \"r\");\n        ifstream is { \"another file\" };\n        // ...\n        if (i == 0) return;\n        // ...\n        fclose(f);\n    }\n\nIf `i == 0` the file handle for `a file` is leaked. On the other hand, the `ifstream` for `another file` will correctly close its file (upon destruction). If you must use an explicit pointer, rather than a resource handle with specific semantics, use a `unique_ptr` or a `shared_ptr` with a custom deleter:\n\n    void f(int i)\n    {\n        unique_ptr<FILE, int(*)(FILE*)> f(fopen(\"a file\", \"r\"), fclose);\n        // ...\n        if (i == 0) return;\n        // ...\n    }\n\nBetter:\n\n    void f(int i)\n    {\n        ifstream input {\"a file\"};\n        // ...\n        if (i == 0) return;\n        // ...\n    }\n\n##### Enforcement\n\nA checker must consider all \"naked pointers\" suspicious.\nA checker probably must rely on a human-provided list of resources.\nFor starters, we know about the standard-library containers, `string`, and smart pointers.\nThe use of `span` and `string_view` should help a lot (they are not resource handles).\n\n### <a name=\"cr-raw\"></a>Discussion: A \"raw\" pointer or reference is never a resource handle\n\n##### Reason\n\nTo be able to distinguish owners from views.\n\n##### Note\n\nThis is independent of how you \"spell\" pointer: `T*`, `T&`, `Ptr<T>` and `Range<T>` are not owners.\n\n### <a name=\"cr-outlive\"></a>Discussion: Never let a pointer outlive the object it points to\n\n##### Reason\n\nTo avoid extremely hard-to-find errors. Dereferencing such a pointer is undefined behavior and could lead to violations of the type system.\n\n##### Example\n\n    string* bad()   // really bad\n    {\n        vector<string> v = { \"This\", \"will\", \"cause\", \"trouble\", \"!\" };\n        // leaking a pointer into a destroyed member of a destroyed object (v)\n        return &v[0];\n    }\n\n    void use()\n    {\n        string* p = bad();\n        vector<int> xx = {7, 8, 9};\n        // undefined behavior: x might not be the string \"This\"\n        string x = *p;\n        // undefined behavior: we don't know what (if anything) is allocated a location p\n        *p = \"Evil!\";\n    }\n\nThe `string`s of `v` are destroyed upon exit from `bad()` and so is `v` itself. The returned pointer points to unallocated memory on the free store. This memory (pointed into by `p`) might have been reallocated by the time `*p` is executed. There might be no `string` to read and a write through `p` could easily corrupt objects of unrelated types.\n\n##### Enforcement\n\nMost compilers already warn about simple cases and have the information to do more. Consider any pointer returned from a function suspect. Use containers, resource handles, and views (e.g., `span` known not to be resource handles) to lower the number of cases to be examined. For starters, consider every class with a destructor as resource handle.\n\n### <a name=\"cr-templates\"></a>Discussion: Use templates to express containers (and other resource handles)\n\n##### Reason\n\nTo provide statically type-safe manipulation of elements.\n\n##### Example\n\n    template<typename T> class Vector {\n        // ...\n        T* elem;   // point to sz elements of type T\n        int sz;\n    };\n\n### <a name=\"cr-value-return\"></a>Discussion: Return containers by value (relying on move or copy elision for efficiency)\n\n##### Reason\n\nTo simplify code and eliminate a need for explicit memory management. To bring an object into a surrounding scope, thereby extending its lifetime.\n\n**See also**: [F.20, the general item about \"out\" output values](#rf-out)\n\n##### Example\n\n    vector<int> get_large_vector()\n    {\n        return ...;\n    }\n\n    auto v = get_large_vector(); //  return by value is ok, most modern compilers will do copy elision\n\n##### Exception\n\nSee the Exceptions in [F.20](#rf-out).\n\n##### Enforcement\n\nCheck for pointers and references returned from functions and see if they are assigned to resource handles (e.g., to a `unique_ptr`).\n\n### <a name=\"cr-handle\"></a>Discussion: If a class is a resource handle, it needs a constructor, a destructor, and copy and/or move operations\n\n##### Reason\n\nTo provide complete control of the lifetime of the resource. To provide a coherent set of operations on the resource.\n\n##### Example\n\n    ??? Messing with pointers\n\n##### Note\n\nIf all members are resource handles, rely on the compiler-generated operations where possible.\n\n    template<typename T> struct Named {\n        string name;\n        T value;\n    };\n\nNow `Named` has a default constructor, a destructor, and efficient copy and move operations, provided `T` has.\n\n##### Enforcement\n\nIn general, a tool cannot know if a class is a resource handle. However, if a class has some of [the default operations](#ss-ctor), it should have all, and if a class has a member that is a resource handle, it should be considered as resource handle.\n\n### <a name=\"cr-list\"></a>Discussion: If a class is a container, give it an initializer-list constructor\n\n##### Reason\n\nIt is common to need an initial set of elements.\n\n##### Example\n\n    template<typename T> class Vector {\n    public:\n        Vector(std::initializer_list<T>);\n        // ...\n    };\n\n    Vector<string> vs { \"Nygaard\", \"Ritchie\" };\n\n##### Enforcement\n\nWhen is a class a container? ???\n\n# <a name=\"s-tools\"></a>Appendix D: Supporting tools\n\nThis section contains a list of tools that directly support adoption of the C++ Core Guidelines. This list is not intended to be an exhaustive list of tools\nthat are helpful in writing good C++ code. If a tool is designed specifically to support and links to the C++ Core Guidelines it is a candidate for inclusion.\n\n### <a name=\"St-clangtidy\"></a>Tools: [Clang-tidy](https://clang.llvm.org/extra/clang-tidy/checks/list.html)\n\nClang-tidy has a set of rules that specifically enforce the C++ Core Guidelines. These rules are named in the pattern `cppcoreguidelines-*`.\n\n### <a name=\"St-cppcorecheck\"></a>Tools: [CppCoreCheck](https://docs.microsoft.com/en-us/visualstudio/code-quality/using-the-cpp-core-guidelines-checkers)\n\nThe Microsoft compiler's C++ code analysis contains a set of rules specifically aimed at enforcement of the C++ Core Guidelines.\n\n# <a name=\"s-glossary\"></a>Glossary\n\nA relatively informal definition of terms used in the guidelines\n(based off the glossary in [Programming: Principles and Practice using C++](https://www.stroustrup.com/programming.html))\n\nMore information on many topics about C++ can be found on the [Standard C++ Foundation](https://isocpp.org)'s site.\n\n* *ABI*: Application Binary Interface, a specification for a specific hardware platform combined with the operating system. Contrast with API.\n* *abstract class*: a class that cannot be directly used to create objects; often used to define an interface to derived classes.\n  A class is made abstract by having a pure virtual function or only protected constructors.\n* *abstraction*: a description of something that selectively and deliberately ignores (hides) details (e.g., implementation details); selective ignorance.\n* *address*: a value that allows us to find an object in a computer's memory.\n* *algorithm*: a procedure or formula for solving a problem; a finite series of computational steps to produce a result.\n* *alias*: an alternative way of referring to an object; often a name, pointer, or reference.\n* *API*: Application Programming Interface, a set of functions that form the communication between various software components. Contrast with ABI.\n* *application*: a program or a collection of programs that is considered an entity by its users.\n* *approximation*: something (e.g., a value or a design) that is close to the perfect or ideal (value or design).\n  Often an approximation is a result of trade-offs among ideals.\n* *argument*: a value passed to a function or a template, in which it is accessed through a parameter.\n* *array*: a homogeneous sequence of elements, usually numbered, e.g., `[0:max)`.\n* *assertion*: a statement inserted into a program to state (assert) that something must always be true at this point in the program.\n* *base class*: a type that is intended to be derived from (e.g., has a non-`final` virtual function), and objects of the type are intended to be used only indirectly (e.g., by pointer). \\[In strict terms, \"base class\" could be defined as \"something we derived from\" but we are specifying in terms of the class designer's intent.\\] Typically a base class has one or more virtual functions.\n* *bit*: the basic unit of information in a computer. A bit can have the value 0 or the value 1.\n* *bug*: an error in a program.\n* *byte*: the basic unit of addressing in most computers. Typically, a byte holds 8 bits.\n* *class*: a user-defined type that can contain data members, function members, and member types.\n* *code*: a program or a part of a program; ambiguously used for both source code and object code.\n* *compiler*: a program that turns source code into object code.\n* *complexity*: a hard-to-precisely-define notion or measure of the difficulty of constructing a solution to a problem or of the solution itself.\n  Sometimes complexity is used to (simply) mean an estimate of the number of operations needed to execute an algorithm.\n* *computation*: the execution of some code, usually taking some input and producing some output.\n* *concept*: (1) a notion, and idea; (2) a set of requirements, usually for a template argument.\n* *concrete type*: a type that is not a base class, and objects of the type are intended to be used directly (not only by pointer/indirection), its size is known, it can typically be allocated anywhere the programmer wants (e.g., stack or statically).\n* *constant*: a value that cannot be changed (in a given scope); not mutable.\n* *constructor*: an operation that initializes (\"constructs\") an object.\n  Typically a constructor establishes an invariant and often acquires resources needed for an object to be used (which are then typically released by a destructor).\n* *container*: an object that holds elements (other objects).\n* *copy*: an operation that makes two objects have values that compare equal. See also move.\n* *correctness*: a program or a piece of a program is correct if it meets its specification.\n  Unfortunately, a specification can be incomplete or inconsistent, or can fail to meet users' reasonable expectations.\n  Thus, to produce acceptable code, we sometimes have to do more than just follow the formal specification.\n* *cost*: the expense (e.g., in programmer time, run time, or space) of producing a program or of executing it.\n  Ideally, cost should be a function of complexity.\n* *customization point*: ???\n* *data*: values used in a computation.\n* *debugging*: the act of searching for and removing errors from a program; usually far less systematic than testing.\n* *declaration*: the specification of a name with its type in a program.\n* *definition*: a declaration of an entity that supplies all information necessary to complete a program using the entity.\n  Simplified definition: a declaration that allocates memory.\n* *derived class*: a class derived from one or more base classes.\n* *design*: an overall description of how a piece of software should operate to meet its specification.\n* *destructor*: an operation that is implicitly invoked (called) when an object is destroyed (e.g., at the end of a scope). Often, it releases resources.\n* *encapsulation*: protecting something meant to be private (e.g., implementation details) from unauthorized access.\n* *error*: a mismatch between reasonable expectations of program behavior (often expressed as a requirement or a users' guide) and what a program actually does.\n* *executable*: a program ready to be run (executed) on a computer.\n* *feature creep*: a tendency to add excess functionality to a program \"just in case.\"\n* *file*: a container of permanent information in a computer.\n* *floating-point number*: a computer's approximation of a real number, such as 7.93 and 10.78e-3.\n* *function*: a named unit of code that can be invoked (called) from different parts of a program; a logical unit of computation.\n* *generic programming*: a style of programming focused on the design and efficient implementation of algorithms.\n  A generic algorithm will work for all argument types that meet its requirements. In C++, generic programming typically uses templates.\n* *global variable*: technically, a named object in namespace scope.\n* *handle*: a class that allows access to another through a member pointer or reference. See also resource, copy, move.\n* *header*: a file containing declarations used to share interfaces between parts of a program.\n* *hiding*: the act of preventing a piece of information from being directly seen or accessed.\n  For example, a name from a nested (inner) scope can prevent that same name from an outer (enclosing) scope from being directly used.\n* *ideal*: the perfect version of something we are striving for. Usually we have to make trade-offs and settle for an approximation.\n* *implementation*: (1) the act of writing and testing code; (2) the code that implements a program.\n* *infinite loop*: a loop where the termination condition never becomes true. See iteration.\n* *infinite recursion*: a recursion that doesn't end until the machine runs out of memory to hold the calls.\n  In reality, such recursion is never infinite but is terminated by some hardware error.\n* *information hiding*: the act of separating interface and implementation, thus hiding implementation details not meant for the user's attention and providing an abstraction.\n* *initialize*: giving an object its first (initial) value.\n* *input*: values used by a computation (e.g., function arguments and characters typed on a keyboard).\n* *integer*: a whole number, such as 42 and -99.\n* *interface*: a declaration or a set of declarations specifying how a piece of code (such as a function or a class) can be called.\n* *invariant*: something that must be always true at a given point (or points) of a program; typically used to describe the state (set of values) of an object or the state of a loop before entry into the repeated statement.\n* *iteration*: the act of repeatedly executing a piece of code; see recursion.\n* *iterator*: an object that identifies an element of a sequence.\n* *ISO*: International Organization for Standardization. The C++ language is an ISO standard, ISO/IEC 14882. More information at [iso.org](https://iso.org).\n* *library*: a collection of types, functions, classes, etc. implementing a set of facilities (abstractions) meant to be potentially used as part of more than one program.\n* *lifetime*: the time from the initialization of an object until it becomes unusable (goes out of scope, is deleted, or the program terminates).\n* *linker*: a program that combines object code files and libraries into an executable program.\n* *literal*: a notation that directly specifies a value, such as 12 specifying the integer value \"twelve.\"\n* *loop*: a piece of code executed repeatedly; in C++, typically a for-statement or a `while`-statement.\n* *move*: an operation that transfers a value from one object to another leaving behind a value representing \"empty.\" See also copy.\n* *move-only type*: a concrete type that is movable but not copyable.\n* *mutable*: changeable; the opposite of immutable, constant, and invariable.\n* *object*: (1) an initialized region of memory of a known type which holds a value of that type; (2) a region of memory.\n* *object code*: output from a compiler intended as input for a linker (for the linker to produce executable code).\n* *object file*: a file containing object code.\n* *object-oriented programming*: (OOP) a style of programming focused on the design and use of classes and class hierarchies.\n* *operation*: something that can perform some action, such as a function and an operator.\n* *output*: values produced by a computation (e.g., a function result or lines of characters written on a screen).\n* *overflow*: producing a value that cannot be stored in its intended target.\n* *overload*: defining two functions or operators with the same name but different argument (operand) types.\n* *override*: defining a function in a derived class with the same name and argument types as a virtual function in the base class, thus making the function callable through the interface defined by the base class.\n* *owner*: an object responsible for releasing a resource.\n* *paradigm*: a somewhat pretentious term for design or programming style; often used with the (erroneous) implication that there exists a paradigm that is superior to all others.\n* *parameter*: a declaration of an explicit input to a function or a template. When called, a function can access the arguments passed through the names of its parameters.\n* *pointer*: (1) a value used to identify a typed object in memory; (2) a variable holding such a value.\n* *post-condition*: a condition that must hold upon exit from a piece of code, such as a function or a loop.\n* *pre-condition*: a condition that must hold upon entry into a piece of code, such as a function or a loop.\n* *program*: code (possibly with associated data) that is sufficiently complete to be executed by a computer.\n* *programming*: the art of expressing solutions to problems as code.\n* *programming language*: a language for expressing programs.\n* *pseudo code*: a description of a computation written in an informal notation rather than a programming language.\n* *pure virtual function*: a virtual function that must be overridden in a derived class.\n* *RAII*: (\"Resource Acquisition Is Initialization\") a basic technique for resource management based on scopes.\n* *range*: a sequence of values that can be described by a start point and an end point. For example, `[0:5)` means the values 0, 1, 2, 3, and 4.\n* *recursion*: the act of a function calling itself; see also iteration.\n* *reference*: (1) a value describing the location of a typed value in memory; (2) a variable holding such a value.\n* *regular expression*: a notation for patterns in character strings.\n* *regular*: a semiregular type that is equality-comparable (see `std::regular` concept). After a copy, the copied object compares equal to the original object. A regular type behaves similarly to built-in types like `int` and can be compared with `==`.\nIn particular, an object of a regular type can be copied and the result of a copy is a separate object that compares equal to the original. See also *semiregular type*.\n* *requirement*: (1) a description of the desired behavior of a program or part of a program; (2) a description of the assumptions a function or template makes of its arguments.\n* *resource*: something that is acquired and must later be released, such as a file handle, a lock, or memory. See also handle, owner.\n* *rounding*: conversion of a value to the mathematically nearest value of a less precise type.\n* *RTTI*: Run-Time Type Information. ???\n* *scope*: the region of program text (source code) in which a name can be referred to.\n* *semiregular*: a concrete type that is copyable (including movable) and default-constructible (see `std::semiregular` concept). The result of a copy is an independent object with the same value as the original. A semiregular type behaves roughly like a built-in type like `int`, but possibly without a `==` operator. See also *regular type*.\n* *sequence*: elements that can be visited in a linear order.\n* *software*: a collection of pieces of code and associated data; often used interchangeably with program.\n* *source code*: code as produced by a programmer and (in principle) readable by other programmers.\n* *source file*: a file containing source code.\n* *specification*: a description of what a piece of code should do.\n* *standard*: an officially agreed upon definition of something, such as a programming language.\n* *state*: a set of values.\n* *STL*: the containers, iterators, and algorithms part of the standard library.\n* *string*: a sequence of characters.\n* *style*: a set of techniques for programming leading to a consistent use of language features; sometimes used in a very restricted sense to refer just to low-level rules for naming and appearance of code.\n* *subtype*: derived type; a type that has all the properties of a type and possibly more.\n* *supertype*: base type; a type that has a subset of the properties of a type.\n* *system*: (1) a program or a set of programs for performing a task on a computer; (2) a shorthand for \"operating system\", that is, the fundamental execution environment and tools for a computer.\n* *TS*: [Technical Specification](https://www.iso.org/deliverables-all.html?type=ts), A Technical Specification addresses work still under technical development, or where it is believed that there will be a future, but not immediate, possibility of agreement on an International Standard. A Technical Specification is published for immediate use, but it also provides a means to obtain feedback. The aim is that it will eventually be transformed and republished as an International Standard.\n* *template*: a class or a function parameterized by one or more types or (compile-time) values; the basic C++ language construct supporting generic programming.\n* *testing*: a systematic search for errors in a program.\n* *trade-off*: the result of balancing several design and implementation criteria.\n* *truncation*: loss of information in a conversion from a type into another that cannot exactly represent the value to be converted.\n* *type*: something that defines a set of possible values and a set of operations for an object.\n* *uninitialized*: the (undefined) state of an object before it is initialized.\n* *unit*: (1) a standard measure that gives meaning to a value (e.g., km for a distance); (2) a distinguished (e.g., named) part of a larger whole.\n* *use case*: a specific (typically simple) use of a program meant to test its functionality and demonstrate its purpose.\n* *value*: a set of bits in memory interpreted according to a type.\n* *value type*: a term some people use to mean a regular or semiregular type.\n* *variable*: a named object of a given type; contains a value unless uninitialized.\n* *virtual function*: a member function that can be overridden in a derived class.\n* *word*: a basic unit of memory in a computer, often the unit used to hold an integer.\n\n# <a name=\"s-unclassified\"></a>To-do: Unclassified proto-rules\n\nThis is our to-do list.\nEventually, the entries will become rules or parts of rules.\nAlternatively, we will decide that no change is needed and delete the entry.\n\n* No long-distance friendship\n* Should physical design (what's in a file) and large-scale design (libraries, groups of libraries) be addressed?\n* Namespaces\n* Avoid using directives in the global scope (except for std, and other \"fundamental\" namespaces (e.g. experimental))\n* How granular should namespaces be? All classes/functions designed to work together and released together (as defined in Sutter/Alexandrescu) or something narrower or wider?\n* Should there be inline namespaces (à la `std::literals::*_literals`)?\n* Avoid implicit conversions\n* Const member functions should be thread safe ... aka, but I don't really change the variable, just assign it a value the first time it's called ... argh\n* Always initialize variables, use initialization lists for data members.\n* Anyone writing a public interface which takes or returns `void*` should have their toes set on fire. That one has been a personal favorite of mine for a number of years. :)\n* Use `const`-ness wherever possible: member functions, variables and (yippee) `const_iterators`\n* Use `auto`\n* `(size)` vs. `{initializers}` vs. `{Extent{size}}`\n* Don't overabstract\n* Never pass a pointer down the call stack\n* falling through a function bottom\n* Should there be guidelines to choose between polymorphisms? YES. classic (virtual functions, reference semantics) vs. Sean Parent style (value semantics, type-erased, kind of like `std::function`)  vs. CRTP/static? YES Perhaps even vs. tag dispatch?\n* should virtual calls be banned from ctors/dtors in your guidelines? YES. A lot of people ban them, even though I think it's a big strength of C++ that they are ??? -preserving (D disappointed me so much when it went the Java way). WHAT WOULD BE A GOOD EXAMPLE?\n* Speaking of lambdas, what would weigh in on the decision between lambdas and (local?) classes in algorithm calls and other callback scenarios?\n* And speaking of `std::bind`, Stephen T. Lavavej criticizes it so much I'm starting to wonder if it is indeed going to fade away in future. Should lambdas be recommended instead?\n* What to do with leaks out of temporaries? : `p = (s1 + s2).c_str();`\n* pointer/iterator invalidation leading to dangling pointers:\n\n        void bad()\n        {\n            int* p = new int[700];\n            int* q = &p[7];\n            delete p;\n\n            vector<int> v(700);\n            int* q2 = &v[7];\n            v.resize(900);\n\n            // ... use q and q2 ...\n        }\n\n* LSP\n* private inheritance vs/and membership\n* avoid static class members variables (race conditions, almost-global variables)\n\n* Use RAII lock guards (`lock_guard`, `unique_lock`, `shared_lock`), never call `mutex.lock` and `mutex.unlock` directly (RAII)\n* Prefer non-recursive locks (often used to work around bad reasoning, overhead)\n* Join your threads! (because of `std::terminate` in destructor if not joined or detached ... is there a good reason to detach threads?) -- ??? could support library provide a RAII wrapper for `std::thread`?\n* If two or more mutexes must be acquired at the same time, use `std::lock` (or another deadlock avoidance algorithm?)\n* When using a `condition_variable`, always protect the condition by a mutex (atomic bool whose value is set outside of the mutex is wrong!), and use the same mutex for the condition variable itself.\n* Never use `atomic_compare_exchange_strong` with `std::atomic<user-defined-struct>` (differences in padding matter, while `compare_exchange_weak` in a loop converges to stable padding)\n* individual `shared_future` objects are not thread-safe: two threads cannot wait on the same `shared_future` object (they can wait on copies of a `shared_future` that refer to the same shared state)\n* individual `shared_ptr` objects are not thread-safe: different threads can call non-`const` member functions on *different* `shared_ptr`s that refer to the same shared object, but one thread cannot call a non-`const` member function of a `shared_ptr` object while another thread accesses that same `shared_ptr` object (if you need that, consider `atomic_shared_ptr` instead)\n\n* rules for arithmetic\n\n# Bibliography\n\n* <a name=\"Abrahams01\"></a>\n  \\[Abrahams01]:  D. Abrahams. [Exception-Safety in Generic Components](https://www.boost.org/community/exception_safety.html).\n* <a name=\"Alexandrescu01\"></a>\n  \\[Alexandrescu01]:  A. Alexandrescu. Modern C++ Design (Addison-Wesley, 2001).\n* <a name=\"Cplusplus03\"></a>\n  \\[C++03]:           ISO/IEC 14882:2003(E), Programming Languages — C++ (updated ISO and ANSI C++ Standard including the contents of (C++98) plus errata corrections).\n* <a name=\"Cargill92\"></a>\n  \\[Cargill92]:       T. Cargill. C++ Programming Style (Addison-Wesley, 1992).\n* <a name=\"Cline99\"></a>\n  \\[Cline99]:         M. Cline, G. Lomow, and M. Girou. C++ FAQs (2ndEdition) (Addison-Wesley, 1999).\n* <a name=\"Dewhurst03\"></a>\n  \\[Dewhurst03]:      S. Dewhurst. C++ Gotchas (Addison-Wesley, 2003).\n* <a name=\"Henricson97\"></a>\n  \\[Henricson97]:     M. Henricson and E. Nyquist. Industrial Strength C++ (Prentice Hall, 1997).\n* <a name=\"Koenig97\"></a>\n  \\[Koenig97]:        A. Koenig and B. Moo. Ruminations on C++ (Addison-Wesley, 1997).\n* <a name=\"Lakos96\"></a>\n  \\[Lakos96]:         J. Lakos. Large-Scale C++ Software Design (Addison-Wesley, 1996).\n* <a name=\"Meyers96\"></a>\n  \\[Meyers96]:        S. Meyers. More Effective C++ (Addison-Wesley, 1996).\n* <a name=\"Meyers97\"></a>\n  \\[Meyers97]:        S. Meyers. Effective C++ (2nd Edition) (Addison-Wesley, 1997).\n* <a name=\"Meyers01\"></a>\n  \\[Meyers01]:        S. Meyers. Effective STL (Addison-Wesley, 2001).\n* <a name=\"Meyers05\"></a>\n  \\[Meyers05]:        S. Meyers. Effective C++ (3rd Edition) (Addison-Wesley, 2005).\n* <a name=\"Meyers15\"></a>\n  \\[Meyers15]:        S. Meyers. Effective Modern C++ (O'Reilly, 2015).\n* <a name=\"Murray93\"></a>\n  \\[Murray93]:        R. Murray. C++ Strategies and Tactics (Addison-Wesley, 1993).\n* <a name=\"Stroustrup94\"></a>\n  \\[Stroustrup94]:    B. Stroustrup. The Design and Evolution of C++ (Addison-Wesley, 1994).\n* <a name=\"Stroustrup00\"></a>\n  \\[Stroustrup00]:    B. Stroustrup. The C++ Programming Language (Special 3rdEdition) (Addison-Wesley, 2000).\n* <a name=\"Stroustrup05\"></a>\n  \\[Stroustrup05]:    B. Stroustrup. [A rationale for semantically enhanced library languages](https://www.stroustrup.com/SELLrationale.pdf).\n* <a name=\"Stroustrup13\"></a>\n  \\[Stroustrup13]:    B. Stroustrup. [The C++ Programming Language (4th Edition)](https://www.stroustrup.com/4th.html). Addison-Wesley 2013.\n* <a name=\"Stroustrup14\"></a>\n  \\[Stroustrup14]:    B. Stroustrup. [A Tour of C++](https://www.stroustrup.com/Tour.html).\n  Addison-Wesley 2014.\n* <a name=\"Stroustrup15\"></a>\n  \\[Stroustrup15]:    B. Stroustrup, Herb Sutter, and G. Dos Reis: [A brief introduction to C++'s model for type- and resource-safety](https://github.com/isocpp/CppCoreGuidelines/blob/master/docs/Introduction%20to%20type%20and%20resource%20safety.pdf).\n* <a name=\"SuttHysl04b\"></a>\n  \\[SuttHysl04b]:     H. Sutter and J. Hyslop. [Collecting Shared Objects](https://web.archive.org/web/20120926011837/http://www.drdobbs.com/collecting-shared-objects/184401839) (C/C++ Users Journal, 22(8), August 2004).\n* <a name=\"SuttAlex05\"></a>\n  \\[SuttAlex05]:      H. Sutter and  A. Alexandrescu. C++ Coding Standards. Addison-Wesley 2005.\n* <a name=\"Sutter00\"></a>\n  \\[Sutter00]:        H. Sutter. Exceptional C++ (Addison-Wesley, 2000).\n* <a name=\"Sutter02\"></a>\n  \\[Sutter02]:        H. Sutter. More Exceptional C++ (Addison-Wesley, 2002).\n* <a name=\"Sutter04\"></a>\n  \\[Sutter04]:        H. Sutter. Exceptional C++ Style (Addison-Wesley, 2004).\n* <a name=\"Taligent94\"></a>\n  \\[Taligent94]: Taligent's Guide to Designing Programs (Addison-Wesley, 1994).\n"
  },
  {
    "path": "LICENSE",
    "content": "Copyright (c) Standard C++ Foundation and its contributors\n\nStandard C++ Foundation grants you a worldwide, nonexclusive, royalty-free,\nperpetual license to copy, use, modify, and create derivative works from this\nproject for your personal or internal business use only. The above copyright\nnotice and this permission notice shall be included in all copies or\nsubstantial portions of the project. This license does not grant permission\nto use the trade names, trademarks, service marks, or product names of the\nlicensor, except as required for reasonable and customary use in describing\nthe origin of the project.\n\nStandard C++ Foundation reserves the right to accept contributions to the\nproject at its discretion.\n\nBy contributing material to this project, you grant Standard C++ Foundation,\nand those who receive the material directly or indirectly from Standard C++\nFoundation, a perpetual, worldwide, non-exclusive, royalty-free, irrevocable,\ntransferrable license to reproduce, prepare derivative works of, publicly\ndisplay, publicly perform, and distribute your contributed material and such\nderivative works, and to sublicense any or all of the foregoing rights to third\nparties for commercial or non-commercial use.  You also grant Standard C++\nFoundation, and those who receive the material directly or indirectly from\nStandard C++ Foundation, a perpetual, worldwide, non-exclusive, royalty-free,\nirrevocable license under your patent claims that directly read on your\ncontributed material to make, have made, use, offer to sell, sell and import\nor otherwise dispose of the material. You warrant that your material is your\noriginal work, or that you have the right to grant the above licenses.\n\nTHE PROJECT IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE PROJECT OR THE USE OR OTHER DEALINGS IN THE\nPROJECT.\n\nIf you believe that anything in the project infringes your copyright, please\ncontact us at admin@isocpp.org with your contact information and a detailed\ndescription of your intellectual property, including a specific URL where you\nbelieve your intellectual property is being infringed.\n\n"
  },
  {
    "path": "README.md",
    "content": "[![C++ Core Guidelines](cpp_core_guidelines_logo_text.png)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines)\n\n>\"Within C++ is a smaller, simpler, safer language struggling to get out.\"  \n>-- <cite>Bjarne Stroustrup</cite>\n\nThe [C++ Core Guidelines](CppCoreGuidelines.md) are a collaborative effort led by Bjarne Stroustrup, much like the C++ language itself. They are the result of many\nperson-years of discussion and design across a number of organizations. Their design encourages general applicability and broad adoption but\nthey can be freely copied and modified to meet your organization's needs.\n\n## Getting started\n\nThe guidelines themselves are found at [CppCoreGuidelines](CppCoreGuidelines.md). The document is in [GH-flavored MarkDown](https://github.github.com/gfm/). It is intentionally kept simple, mostly in ASCII, to allow automatic post-processing such as language translation and reformatting. The editors maintain one\n[version formatted for browsing](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines). Note that it is manually integrated and can be slightly older than the version in the master branch.\n\nThe Guidelines are a constantly evolving document without a strict \"release\" cadence. Bjarne Stroustrup periodically reviews the document and increments the version number in the introduction. [Checkins that increment the version number](https://github.com/isocpp/CppCoreGuidelines/releases) are tagged in git. \n\nMany of the guidelines make use of the header-only Guidelines Support Library. One implementation is available at [GSL: Guidelines Support Library](https://github.com/Microsoft/GSL).\n\n## Background and scope\n\nThe aim of the guidelines is to help people to use modern C++ effectively. By \"modern C++\" we mean C++11 and newer. In other\nwords, what would you like your code to look like in 5 years' time, given that you can start now? In 10 years' time?\n\nThe guidelines are focused on relatively higher-level issues, such as interfaces, resource management, memory management, and concurrency. Such\nrules affect application architecture and library design. Following the rules will lead to code that is statically type-safe, has no resource\nleaks, and catches many more programming logic errors than is common in code today. And it will run fast -- you can afford to do things right.\n\nWe are less concerned with low-level issues, such as naming conventions and indentation style. However, no topic that can help a programmer is\nout of bounds.\n\nOur initial set of rules emphasizes safety (of various forms) and simplicity. They may very well be too strict. We expect to have to introduce\nmore exceptions to better accommodate real-world needs. We also need more rules.\n\nYou will find some of the rules contrary to your expectations or even contrary to your experience. If we haven't suggested that you change your\ncoding style in any way, we have failed! Please try to verify or disprove rules! In particular, we'd really like to have some of our rules\nbacked up with measurements or better examples.\n\nYou will find some of the rules obvious or even trivial. Please remember that one purpose of a guideline is to help someone who is less\nexperienced or coming from a different background or language to get up to speed.\n\nThe rules are designed to be supported by an analysis tool. Violations of rules will be flagged with references (or links) to the relevant rule.\nWe do not expect you to memorize all the rules before trying to write code.\n\nThe rules are meant for gradual introduction into a code base. We plan to build tools for that and hope others will too.\n\n## Contributions and LICENSE\n\nComments and suggestions for improvements are most welcome. We plan to modify and extend this document as our understanding improves and the\nlanguage and the set of available libraries improve. More details are found at [CONTRIBUTING](./CONTRIBUTING.md) and [LICENSE](./LICENSE).\n\nThanks to [DigitalOcean](https://www.digitalocean.com/?refcode=32f291566cf7&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=CopyPaste) for hosting the Standard C++ Foundation website.\n"
  },
  {
    "path": "SECURITY.md",
    "content": "# Security Policy\n\n## Reporting a Vulnerability\n\nPlease report vulnerabilities, if any, to cppcg-editors@isocpp.org\n"
  },
  {
    "path": "_config.yml",
    "content": "include: [CppCoreGuidelines.md]\nexclude: [docs, talks, Gemfile, params.json]\n"
  },
  {
    "path": "_includes/head.html",
    "content": "<head>\n  <link href=\"http://gmpg.org/xfn/11\" rel=\"profile\">\n  <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\">\n  <meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\">\n\n  <!-- Enable responsiveness on mobile devices-->\n  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, maximum-scale=1\">\n\n  <title>C++ Core Guidelines</title>\n\n  <link rel=\"stylesheet\" href=\"https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.9.0/styles/github.min.css\">\n  <script src=\"https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.9.0/highlight.min.js\"></script>\n\n  <!-- CSS, could be merged and minified for improved loading speed -->\n  <link rel=\"stylesheet\" href=\"{{ site.baseurl }}/public/css/poole.css\">\n  <link rel=\"stylesheet\" href=\"{{ site.baseurl }}/public/css/hyde.css\">\n  <link rel=\"stylesheet\" href=\"{{ site.baseurl }}/public/css/custom.css\">\n\n  <link rel=\"stylesheet\" type=\"text/css\" href=\"https://fonts.googleapis.com/css?family=PT+Sans:400,400italic,700|Abril+Fatface|Roboto+Mono\">\n  <meta name=\"description\" content=\"{% if page.excerpt %}{{ page.excerpt | strip_html | strip_newlines | truncate: 160 }}{% else %}{{ site.description }}{% endif %}\">\n\n\n  <!-- Include jquery.js -->\n  <script src=\"https://cdnjs.cloudflare.com/ajax/libs/jquery/3.1.1/jquery.min.js\"></script>\n\n\n  <!-- make sure you include the latest version -->\n  <script src=\"https://cdnjs.cloudflare.com/ajax/libs/anchor-js/3.2.2/anchor.min.js\"></script>\n\n  <!-- No highlight on page load -->\n  <script type=\"text/javascript\">\n    $( document ).ready(function() {\n     $(\"code\").addClass(\"no-highlight\");\n    });\n  </script>\n\n  <!-- AnchoJs links next to headers-->\n  <script type=\"text/javascript\">\n    $( document ).ready(function () {\n      anchors.add(\"h1, h2, h3\");\n    });\n  </script>\n\n  <!-- hack to toggle highlight on or off -->\n  <script type=\"text/javascript\">\n    function stripSpans(i, spanTag) {\n      var text = spanTag.textContent || spanTag.innerText;\n      var node = document.createTextNode(text);\n      spanTag.parentNode.replaceChild(node, spanTag);\n    }\n    $(function() {\n      $(\"#hl_button\")\n        .click(function( event ) {\n          $(\"pre code\").toggleClass(\"cpp\");\n          $(\"pre code\").toggleClass(\"hljs\");\n          $(\"pre code\").toggleClass(\"no-highlight\");\n          $(\"pre code\").each(function(i, block) {\n            hljs.highlightBlock(block);\n          });\n          $(\"code.no-highlight\").find(\"span\").each(stripSpans);\n        });\n    });\n  </script>\n</head>\n\n"
  },
  {
    "path": "_includes/sidebar.html",
    "content": "<div class=\"sidebar\">\n  <div class=\"container sidebar-sticky\">\n    <div class=\"sidebar-about\">\n      <img src=\"cpp_core_guidelines_16b.png\"/>\n      <!--\n      <h3>\n        <!- -<a href=\"{{ site.baseurl }}\">- ->\n        <a href=\"https://github.com/isocpp/CppCoreGuidelines\">  \n          C++ Core Guidelines\n        </a>\n      </h3>\n      -->\n    </div>\n    <nav class=\"sidebar-nav\">\n      <small>\n        {% if page.name == \"CppCoreGuidelines.md\" %}\n\n        <div class=\"switch\">\n          <input class=\"tgl tgl-cpp\" id=\"hl_button\" type=\"checkbox\"/>\n          <label class=\"tgl-btn\" data-tg-off=\"Turn ON syntax highlighting\" data-tg-on=\"Turn OFF syntax highlighting\" for=\"hl_button\"></label>\n        </div>\n      <!-- Items have to be added manually until for now -->\n      <b><a class=\"sidebar-nav-item active\" href=\"#main\">Top</a></b>\n\n      <a class=\"sidebar-nav-item active\" href=\"#s-introduction\">In: Introduction</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-philosophy\">P: Philosophy</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-interfaces\">I: Interfaces</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-functions\">F: Functions</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-class\">C: Classes and class hierarchies</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-enum\">Enum: Enumerations</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-resource\">R: Resource management</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-expr\">ES: Expressions and statements</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-performance\">Per: Performance</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-concurrency\">CP: Concurrency</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-errors\">E: Error handling</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-const\">Con: Constants and immutability</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-templates\">T: Templates and generic programming</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-cpl\">CPL: C-style programming</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-source\">SF: Source files</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-stdlib\">SL: The Standard library</a>\n      <br/>\n      <a class=\"sidebar-nav-item active\" href=\"#s-a\">A: Architectural Ideas</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-not\">NR: Non-Rules and myths</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-references\">RF: References</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-profile\">Pro: Profiles</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-gsl\">GSL: Guideline support library</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-naming\">NL: Naming and layout</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-faq\">FAQ: Frequently asked questions</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-libraries\">Appendix A: Libraries</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-modernizing\">Appendix B: Modernizing code</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-discussion\">Appendix C: Discussion</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-tools\">Appendix D: Tools support</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-glossary\">Glossary</a>\n      <a class=\"sidebar-nav-item active\" href=\"#s-unclassified\">To-do: Unclassified proto-rules</a>\n        {% else %}\n\n      <a class=\"sidebar-nav-item active\" href=\"CppCoreGuidelines.html\">Read the C++ Core Guidelines</a>\n      <br/>\n      <a class=\"sidebar-nav-item active\" href=\"index.html\">View project README</a>\n      <a class=\"sidebar-nav-item active\" href=\"CONTRIBUTING.md\">View project Contributing</a>\n      <a class=\"sidebar-nav-item active\" href=\"LICENSE\">View project License</a>\n        {% endif %}\n\n      </small>\n\n    </nav>\n\n    <!-- <p>Generated {{ site.time | date: '%Y-%m-%d' }}.</p> -->\n  </div>\n</div>\n"
  },
  {
    "path": "_layouts/default.html",
    "content": "<!DOCTYPE html>\n<html lang=\"en-us\">\n\n  {% include head.html %}\n\n  <body>\n\n    {% include sidebar.html %}\n\n    <div class=\"banner\"><a href=\"https://github.com/isocpp/CppCoreGuidelines\"><img style=\"position: absolute; top: 0; right: 0; border: 0;\" src=\"https://camo.githubusercontent.com/365986a132ccd6a44c23a9169022c0b5c890c387/68747470733a2f2f73332e616d617a6f6e6177732e636f6d2f6769746875622f726962626f6e732f666f726b6d655f72696768745f7265645f6161303030302e706e67\" alt=\"Fork me on GitHub\" data-canonical-src=\"https://s3.amazonaws.com/github/ribbons/forkme_right_red_aa0000.png\"></a></div>\n\n    <div class=\"content container\">\n      {{ content }}\n    </div>\n\n  </body>\n</html>\n"
  },
  {
    "path": "docs/dyn_array.md",
    "content": "<!-- $ pandoc -V geometry:margin=1in -V colorlinks=true -o dyn_array.pdf dyn_array.md --> \n\n# `gsl::dyn_array<T, Allocator>`\n\n`gsl::dyn_array` is a dynamic array that is intended to be a replacement for slinging\naround raw pointers and sizes. Notably, it _owns_ all of its elements. It should replace\nthe following idioms:\n\n* Replace `new T[n]` with `gsl::dyn_array<T>(n)`.\n* Replace both `foo(T*, size_t)` and `foo(unique_ptr<T[]>&, size_t)` with\n`foo(gsl::dyn_array<T>&)`.\n\nIt can be thought of like a...\n\n* `std::array` except the size is specified at runtime.\n* `std::vector` except it can neither shrink nor grow.\n\nBy design, `gsl::dyn_array` is not a `Container` as defined by the C++ Named\nRequirements because we want to avoid the invalidation of iterators or references to\n`gsl::dyn_array` objects.  Furthermore, by design, there is no support for operations\n(other than destruction) that can invalidate iterators or pointers into the sequence\nowned by a `gsl::dyna_array` object. An `gsl::dyn_array` object cannot be moved,\nnor can it be copied.\n\n### Construction\n`gsl::dyn_array`s can be constructed in the following ways:\n\n* Default construct a `dyn_array` with no elements:\n```c++\nconstexpr dyn_array();\n```\n\n* Move construct a `dyn_array` from `other`: not possible\n```c++\ndyn_array(dyn_array&& other) = delete;\n```\n\n* Construct a `dyn_array` with `n` default constructed elements:\n```c++\nconstexpr explicit dyn_array(size_t n, const Allocator & alloc = Allocator());\n```\n\n* Construct a `dyn_array` with `n` elements, each copy constructed from `arg`:\n```c++\nconstexpr dyn_array(size_t n, const T& arg, const Allocator & alloc = Allocator());\n``` \n\n* Construct a `dyn_array` with elements from the range `[first, last)`:\n```c++\ntemplate <typename InputIt>\n#ifdef __cpp_lib_concepts\n    requires(std::input_iterator<InputIt>)\n#endif /* __cpp_lib_concepts */\nconstexpr dyn_array(InputIt first, InputIt last, const Allocator & alloc = Allocator());\n```\n\n* Construct a `dyn_array` from a range:\n```c++\n#ifdef __cpp_lib_containers_range\ntemplate <typename R>\n    requires(std::ranges::range<R>)\nconstexpr dyn_array(std::from_range_t, R&& r, const Allocator & alloc = Allocator());\n#endif /* __cpp_lib_containers_range */\n```\n\n* Construct a `dyn_array` with elements from the initializer list:\n```c++\nconstexpr dyn_array(std::initializer_list<T>, const Allocator & alloc = Allocator());\n```\n\n### Operations\nIn addition to the operations required by the named requirements, `gsl::dyn_array` will\nsupport the following operations:\n\n* Access the specified element **_with bounds checking_**:\n```c++\nconstexpr T& operator[](size_t);\nconstexpr const T& operator[](size_t) const;\n```\n\n* Access the underlying array:\n```c++\nconstexpr T* data() noexcept;\nconstexpr const T* data() const noexcept;\n```\n \n* Return the number of elements in the `dyn_array`:\n```c++\nconstexpr size_t size() const noexcept;\n```\n\n### FAQ\n\n#### Why no push_back (and friends)?\n`gsl::dyn_array` is intended to be a fixed-size array and all objects should be\nconstructed at creation.  It supports no iterator/pointer-invalidating operation.\n\n#### Why does `gsl::dyn_array` not conform to the `Container` Named Requirements?\n`gsl::dyn_array` is intended to be a safer replacement for raw pointers and sizes. We\ndon't want users to accidentally use it in a way that would be unsafe. For example,\n`gsl::dyn_array` does not have copy or move operations. This is because it\nwould be possible to invalidate existing iterators and references.\n\n### Bounds Checking Semantics\nIf an out-of-bounds access (read or write) is attempted, `gsl::dyn_array` should follow\nthe contract violation strategy outlined in [GSL.assert: Assertions](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#gslassert-assertions).\n\n### References\n* [C++ Named Requirements](https://en.cppreference.com/w/cpp/named_req)\n* [Microsoft/GSL #1169](https://github.com/microsoft/GSL/issues/1169)\n* [isocpp/CppCoreGuidelines #2244](https://github.com/isocpp/CppCoreGuidelines/issues/2244)\n* [n3662](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3662.html)\n"
  },
  {
    "path": "docs/gsl-intro.md",
    "content": "\n# Using the Guidelines Support Library (GSL): A Tutorial and FAQ\n\nby Herb Sutter\n\nupdated 2018-01-08\n\n\n## Overview: \"Is this document a tutorial or a FAQ?\"\n\nIt aims to be both:\n\n- a tutorial you can read in order, following a similar style as the introduction of [K&R](https://en.wikipedia.org/wiki/The_C_Programming_Language) by building up examples of increasing complexity; and\n\n- a FAQ you can use as a reference, with each section showing the answer to a specific question.\n\n\n## Motivation: \"Why would I use GSL, and where can I get it?\"\n\nFirst look at the [C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines); this is a support library for that document. Select a set of guidelines you want to adopt, then bring in the GSL as directed by those guidelines.\n\nYou can try out the examples in this document on all major compilers and platforms using [this GSL reference implementation](https://github.com/microsoft/gsl).\n\n\n# gsl::span: \"What is gsl::span, and what is it for?\"\n\n`gsl::span` is a replacement for `(pointer, length)` pairs to refer to a sequence of contiguous objects. It can be thought of as a pointer to an array, but that knows its bounds.\n\nFor example, a `span<int,7>` refers to a sequence of seven contiguous integers.\n\nA `span` does not own the elements it points to. It is not a container like an `array` or a `vector`, it is a view into the contents of such a container.\n\n\n## span parameters: \"How should I choose between span and traditional (ptr, length) parameters?\"\n\nIn new code, prefer the bounds-checkable `span<T>` instead of separate pointer and length parameters. In older code, adopt `span` where reasonable as you maintain the code.\n\nA function that takes a pointer to an array and a separate length, such as:\n\n~~~cpp\n// Error-prone: Process n contiguous ints starting at *p\nvoid dangerous_process_ints(const int* p, size_t n);\n~~~\n\nis error-prone and difficult to use correctly:\n\n~~~cpp\nint a[100];\ndangerous_process_ints(a, 1000); // oops: buffer overflow\n\nvector<int> v(200);\ndangerous_process_ints(v.data(), 1000); // oops: buffer overflow\n\nauto remainder = find(v.begin(), v.end(), some_value);\n    // now call dangerous_process_ints() to fill the rest of the container from *remainder to the end\ndangerous_process_ints(&*remainder, v.end() - remainder); // correct but convoluted\n~~~\n\nInstead, using `span` encapsulates the pointer and the length:\n\n~~~cpp\n// BETTER: Read s.size() contiguous ints starting at s[0]\nvoid process_ints(span<const int> s);\n~~~\n\nwhich makes `process_ints` easier to use correctly because it conveniently deduces from common types:\n\n~~~cpp\nint a[100];\nprocess_ints(a); // deduces correct length: 100 (constructs the span from a container)\n\nvector<int> v(200);\nprocess_ints(v); // deduces correct length: 200 (constructs the span from a container)\n~~~\n\nand conveniently supports modern C++ argument initialization when the calling code does have distinct pointer and length arguments:\n\n~~~cpp\nauto remainder = find(v.begin(), v.end(), some_value);\n    // now call process_ints() to fill the rest of the container from *remainder to the end\nprocess_ints({remainder, v.end()}); // correct and clear (constructs the span from an iterator pair)\n~~~\n\n> Things to remember\n> - Prefer `span` instead of (pointer, length) pairs.\n> - Pass a `span` like a pointer (i.e., by value for \"in\" parameters). Treat it like a pointer range.\n\n\n## span and const: \"What's the difference between `span<const T>` and `const span<T>`?\"\n\n`span<const T>` means that the `T` objects are read-only. Prefer this by default, especially as a parameter, if you don't need to modify the `T`s.\n\n`const span<T>` means that the `span` itself can't be made to point at a different target.\n\n`const span<const T>` means both.\n\n> Things to remember\n> - Prefer a `span<const T>` by default to denote that the contents are read-only, unless you do need read-write access.\n\n\n## Iteration: \"How do I iterate over a span?\"\n\nA `span` is an encapsulated range, and so can be visited using a range-based `for` loop.\n\nConsider the implementation of a function like the `process_ints` that we saw in an earlier example. Visiting every object using a (pointer, length) pair requires an explicit index:\n\n~~~cpp\nvoid dangerous_process_ints(int* p, size_t n) {\n    for (auto i = 0; i < n; ++i) {\n        p[i] = next_character();\n    }\n}\n~~~\n\nA `span` supports range-`for` -- note this is zero-overhead and does not need to perform any range check, because the range-`for` loop is known by construction not to exceed the range's bounds:\n\n~~~cpp\nvoid process_ints(span<int> s) {\n    for (auto& c : s) {\n        c = next_character();\n    }\n}\n~~~\n\nA `span` also supports normal iteration using `.begin()` and `.end()`.\n\nNote that you cannot compare iterators from different spans, even if they refer to the same array.\n\nAn iterator is valid as long as the `span` that it is iterating over exists.\n\n\n## Element access: \"How do I access a single element in a span?\"\n\nUse `myspan[offset]` to subscript, or equivalently use `iter + offset` wheren `iter` is a `span<T>::iterator`. Both are range-checked.\n\n\n\n## Sub-spans: \"What if I need a subrange of a span?\"\n\nTo refer to a sub-span, use `first`, `last`, or `subspan`.\n\n~~~cpp\nvoid process_ints(span<widget> s) {\n    if (s.length() > 10) {\n        read_header(s.first(10));   // first 10 entries\n        read_rest(s.subspan(10));   // remaining entries\n        // ...\n    }\n}\n~~~\n\nIn rarer cases, when you know the number of elements at compile time and want to enable `constexpr` use of `span`, you can pass the length of the sub-span as a template argument:\n\n~~~cpp\nconstexpr int process_ints(span<widget> s) {\n    if (s.length() > 10) {\n        read_header(s.first<10>());   // first 10 entries\n        read_rest(s.subspan<10>());   // remaining entries\n        // ...\n    }\n    return s.size();\n}\n~~~\n\n\n## span and STL: \"How do I pass a span to an STL-style [begin,end) function?\"\n\nUse `span::iterator`s. A `span` is iterable like any STL range.\n\nTo call an STL `[begin,end)`-style interface, use `begin` and `end` by default, or other valid iterators if you don't want to pass the whole range:\n\n~~~cpp\nvoid f(span<widget> s) {\n    // ... \n    auto found = find_if(s.begin(), s.end(), some_value);\n    // ... \n}\n~~~\n\nIf you are using a range-based algorithm such as from [Range-V3](https://github.com/ericniebler/range-v3), you can use a `span` as a range directly:\n\n~~~cpp\nvoid f(span<widget> s) {\n    // ... \n    auto found = find_if(s, some_value); \n    // ... \n}\n~~~\n\n\n## Comparison: \"When I compare `span<T>`s, do I compare the `T` values or the underlying pointers?\"\n\nComparing two `span<T>`s compares the `T` values. To compare two spans for identity, to see if they're pointing to the same thing, use `.data()`.\n\n~~~cpp\nint a[] = { 1, 2, 3};\nspan<int> sa{a};\n\nvector<int> v = { 1, 2, 3 };\nspan<int> sv{v};\n\nassert(sa == sv); // sa and sv both point to contiguous ints with values 1, 2, 3\nassert(sa.data() != sv.data()); // but sa and sv point to different memory areas\n~~~  \n\n> Things to remember\n> - Comparing spans compares their contents, not whether they point to the same location.\n\n\n## Empty vs null: \"Do I have to explicitly check whether a span is null?\"\n\nUsually not, because the thing you usually want to check for is that the `span` is not empty, which means its size is not zero. It's safe to test the size of a span even if it's null. \n\nRemember that the following all have identical meaning for a `span s`:\n\n- `!s.empty()`\n- `s.size() != 0`\n- `s.data() != nullptr && s.size() != 0` (the first condition is actually redundant)\n\nThe following is also functionally equivalent as it just tests whether there are zero elements:\n\n- `s != nullptr` (compares `s` against a null-constructed empty `span`)\n\nFor example:\n\n~~~cpp\nvoid f(span<const int> s) {\n    if (s != nullptr && s.size() > 0) { // bad: redundant, overkill\n        // ...\n    }\n\n    if (s.size() > 0) { // good: not redundant\n        // ...\n    }\n\n    if (!s.empty()) { // good: same as \"s.size() > 0\"\n        // ...\n    }\n}\n\n~~~\n\n> Things to remember\n> - Usually you shouldn't check for a null `span`. For a `span s`, if you're comparing `s != nullptr` or `s.data() != nullptr`, check to make sure you shouldn't just be asking `!s.empty()`.\n\n\n## as_bytes: \"Why would I convert a span to `span<const byte>`?\"\n\nBecause it's a type-safe way to get a read-only view of the objects' bytes.  \n\nWithout `span`, to view the bytes of an object requires writing a brittle cast:\n\n~~~cpp\nvoid serialize(char* p, int length); // bad: forgot const\n\nvoid f(widget* p, int length) {\n    // serialize one object's bytes (incl. padding)\n    serialize(p, 1); // bad: copies just the first byte, forgot sizeof(widget)\n}\n~~~\n\nWith `span` the code is safer and cleaner:\n\n~~~cpp\nvoid serialize(span<const byte>); // can't forget const, the first test call site won't compile\n\nvoid f(span<widget> s) {\n    // ...\n    // serialize one object's bytes (incl. padding)\n    serialize(as_bytes(s)); // ok\n}\n~~~\n\nAlso, `span<T>` lets you distinguish between `.size()` and `.size_bytes()`; make use of that distinction instead of multiplying by `sizeof(T)`.\n\n> Things to remember\n> - Prefer `span<T>`'s `.size_bytes()` instead of `.size() * sizeof(T)`.\n\n\n## And a few `span`-related hints\n\nThese are not directly related to `span` but can often come up while using `span`.\n\n   * Use `byte` everywhere you are handling memory (as opposed to characters or integers). That is, when accessing a chunk of raw memory, use `gsl::span<std::byte>`.\n\n   * Use `narrow()` when you cannot afford to be surprised by a value change during conversion to a smaller range. This includes going between a signed `span` size or index and an unsigned today's-STL-container `.size()`, though the `span` constructors from containers nicely encapsulate many of these conversions.\n\n   * Similarly, use `narrow_cast()` when you are *sure* you won’t be surprised by a value change during conversion to a smaller range\n"
  },
  {
    "path": "index.html",
    "content": "---\nlayout: default\n---\n\n<p  class=\"sidebar-about\">This site is copy of the C++ Core Guidelines rendered for easier browsing. As the text on this page is integrated manually \n    you should refer to the <a href=\"https://github.com/isocpp/CppCoreGuidelines\">C++ Core Guidelines repo</a> for the most up-to-date version.\n</p>\n\n    <!-- HEADER -->\n    <div id=\"header_wrap\" class=\"outer\">\n        <header class=\"inner\">\n            <!--\n            <section id=\"downloads\">\n              <a class=\"zip_download_link\" href=\"https://github.com/tkruse/CppCoreGuidelines/zipball/master\">Download this project as a .zip file</a>\n              <a class=\"tar_download_link\" href=\"https://github.com/tkruse/CppCoreGuidelines/tarball/master\">Download this project as a tar.gz file</a>\n            </section>\n            -->\n        </header>\n    </div>\n\n{% capture readme %}{% include_relative README.md %}{% endcapture %}\n{{ readme | markdownify }}\n"
  },
  {
    "path": "params.json",
    "content": "{\"name\":\"Cppcoreguidelines\",\"tagline\":\"The C++ Core Guidelines are a set of tried-and-true guidelines, rules, and best practices about coding in C++\",\"body\":\"# C++ Core Guidelines\\r\\n\\r\\n>\\\"Within C++ is a smaller, simpler, safer language struggling to get out.\\\" \\r\\n>-- <cite>Bjarne Stroustrup</cite>\\r\\n\\r\\nThe C++ Core Guidelines are a collaborative effort led by Bjarne Stroustrup, much like the C++ language itself. They are the result of many \\r\\nperson-years of discussion and design across a number of organizations. Their design encourages general applicability and broad adoption but \\r\\nthey can be freely copied and modified to meet your organization's needs. \\r\\n\\r\\nThe aim of the guidelines is to help people to use modern C++ effectively. By \\\"modern C++\\\" we mean C++11 and C++14 (and soon C++17). In other \\r\\nwords, what would you like your code to look like in 5 years' time, given that you can start now? In 10 years' time?\\r\\n\\r\\nThe guidelines are focused on relatively higher-level issues, such as interfaces, resource management, memory management, and concurrency. Such \\r\\nrules affect application architecture and library design. Following the rules will lead to code that is statically type safe, has no resource \\r\\nleaks, and catches many more programming logic errors than is common in code today. And it will run fast - you can afford to do things right.\\r\\n\\r\\nWe are less concerned with low-level issues, such as naming conventions and indentation style. However, no topic that can help a programmer is \\r\\nout of bounds.\\r\\n\\r\\nOur initial set of rules emphasize safety (of various forms) and simplicity. They may very well be too strict. We expect to have to introduce \\r\\nmore exceptions to better accommodate real-world needs. We also need more rules.\\r\\n\\r\\nYou will find some of the rules contrary to your expectations or even contrary to your experience. If we haven't suggested you change your \\r\\ncoding style in any way, we have failed! Please try to verify or disprove rules! In particular, we'd really like to have some of our rules \\r\\nbacked up with measurements or better examples.\\r\\n\\r\\nYou will find some of the rules obvious or even trivial. Please remember that one purpose of a guideline is to help someone who is less \\r\\nexperienced or coming from a different background or language to get up to speed.\\r\\n\\r\\nThe rules are designed to be supported by an analysis tool. Violations of rules will be flagged with references (or links) to the relevant rule. \\r\\nWe do not expect you to memorize all the rules before trying to write code.\\r\\n\\r\\nThe rules are meant for gradual introduction into a code base. We plan to build tools for that and hope others will too.\\r\\n\\r\\nComments and suggestions for improvements are most welcome. We plan to modify and extend this document as our understanding improves and the \\r\\nlanguage and the set of available libraries improve.\\r\\n\",\"google\":\"\",\"note\":\"Don't delete this file! It's used internally to help with page regeneration.\"}"
  },
  {
    "path": "public/css/custom.css",
    "content": ".outer {\n  width: 100%;\n}\n\n.inner {\n  position: relative;\n  max-width: 1280px;\n  padding: 20px 10px;\n  margin: 0 auto;\n}\n\n\n#header_wrap {\n  background: #212121;\n  background: -moz-linear-gradient(top, #373737, #212121);\n  background: -webkit-linear-gradient(top, #373737, #212121);\n  background: -ms-linear-gradient(top, #373737, #212121);\n  background: -o-linear-gradient(top, #373737, #212121);\n  background: linear-gradient(top, #373737, #212121);\n}\n\n#header_wrap .inner {\n  padding: 50px 10px 30px 10px;\n}\n\n#downloads {\n  position: absolute;\n  width: 210px;\n  z-index: 10;\n  bottom: -40px;\n  right: 0;\n  height: 70px;\n  background: url('../images/icon_download.png') no-repeat 0% 90%;\n}\n\n/** same style for highlighted, non-highlight */\n.cpp.hljs {\n  overflow-x: unset;\n}\n\n/** override poole.css */\npre code {\n  /* same as hljs */\n  padding: 0.5em;\n}\n\n/** highlight js change colors (overrides style) */\n.hljs-comment {\n  color: #008000;\n}\n.hljs-meta {\n  color: #2b91af;\n}\n\n.zip_download_link {\n  display: block;\n  float: right;\n  width: 90px;\n  height:70px;\n  text-indent: -5000px;\n  overflow: hidden;\n  background: url(../images/sprite_download.png) no-repeat bottom left;\n}\n\n.tar_download_link {\n  display: block;\n  float: right;\n  width: 90px;\n  height:70px;\n  text-indent: -5000px;\n  overflow: hidden;\n  background: url(../images/sprite_download.png) no-repeat bottom right;\n  margin-left: 10px;\n}\n\n.zip_download_link:hover {\n  background: url(../images/sprite_download.png) no-repeat top left;\n}\n\n.tar_download_link:hover {\n  background: url(../images/sprite_download.png) no-repeat top right;\n}\n\n/**\n * Try to display h5 headers left of paragraphs\n */\n\nh5 {\n    display: inline;\n}\n\nh5:before {\n    content: '\\A'; white-space:pre-line;\n}\n\nh5 + p {\n    display: inline;\n}\n\np:after {\n    content: '\\A'; white-space:pre-line;\n}\n\n@media print {\n    .sidebar,.banner, a:after {\n        display: none;\n    }\n    .container {\n        width: 90%;\n        margin: 2em;\n        padding: 0px;\n    }\n    .* {\n        color: #000;\n        background-color: #fff;\n        @include box-shadow(none);\n        @include text-shadow(none);\n    }\n    code,p {\n        page-break-inside:avoid;\n        page-break-before:avoid;\n    }\n    pre code {\n        /* try to fit 100 max chars into one A4 line */\n        font-size: 2.8mm;\n    }\n    h1,h2,h3,h4,h5,strong {\n        page-break-after:avoid;\n    }\n    h1,h2 {\n        page-break-before:always;\n    }\n    a:link, a:visited {\n        color: #000;\n    }\n}\n\n\n.tgl {\n  display: none;\n}\n.tgl + .tgl-btn {\n  outline: 0;\n  display: block;\n  width: 8em;\n  height: 2em;\n  position: relative;\n  cursor: pointer;\n  -webkit-user-select: none;\n     -moz-user-select: none;\n      -ms-user-select: none;\n          user-select: none;\n}\n.tgl + .tgl-btn:after, .tgl + .tgl-btn:before {\n  position: relative;\n  display: block;\n  content: \"\";\n  width: 50%;\n  height: 100%;\n}\n.tgl + .tgl-btn:after {\n  left: 0;\n}\n.tgl + .tgl-btn:before {\n  display: none;\n}\n.tgl:checked + .tgl-btn:after {\n  left: 50%;\n}\n\n.tgl-cpp + .tgl-btn {\n  overflow: hidden;\n  -webkit-backface-visibility: hidden;\n          backface-visibility: hidden;\n  background: #888;\n}\n.tgl-cpp + .tgl-btn:after, .tgl-cpp + .tgl-btn:before {\n  display: inline-block;\n  width: 100%;\n  text-align: center;\n  position: absolute;\n  line-height: 2em;\n  font-weight: bold;\n  color: #fff;\n}\n.tgl-cpp + .tgl-btn:after {\n  left: 100%;\n  content: attr(data-tg-on);\n}\n.tgl-cpp + .tgl-btn:before {\n  left: 0;\n  content: attr(data-tg-off);\n}\n.tgl-cpp + .tgl-btn:active {\n  background: #888;\n}\n.tgl-cpp:checked + .tgl-btn {\n  background: #268bd2;\n}\n.tgl-cpp:checked + .tgl-btn:before {\n  left: -100%;\n}\n.tgl-cpp:checked + .tgl-btn:after {\n  left: 0;\n}\n\n//\n// rougify style github\n//\n.highlight table td { padding: 5px; }\n.highlight table pre { margin: 0; }\n.highlight .cm {\n  color: #999988;\n  font-style: italic;\n}\n.highlight .cp {\n  color: #999999;\n  font-weight: bold;\n}\n.highlight .c1 {\n  color: #999988;\n  font-style: italic;\n}\n.highlight .cs {\n  color: #999999;\n  font-weight: bold;\n  font-style: italic;\n}\n.highlight .c, .highlight .ch, .highlight .cd, .highlight .cpf {\n  color: #999988;\n  font-style: italic;\n}\n.highlight .err {\n  color: #a61717;\n  background-color: #e3d2d2;\n}\n.highlight .gd {\n  color: #000000;\n  background-color: #ffdddd;\n}\n.highlight .ge {\n  color: #000000;\n  font-style: italic;\n}\n.highlight .gr {\n  color: #aa0000;\n}\n.highlight .gh {\n  color: #999999;\n}\n.highlight .gi {\n  color: #000000;\n  background-color: #ddffdd;\n}\n.highlight .go {\n  color: #888888;\n}\n.highlight .gp {\n  color: #555555;\n}\n.highlight .gs {\n  font-weight: bold;\n}\n.highlight .gu {\n  color: #aaaaaa;\n}\n.highlight .gt {\n  color: #aa0000;\n}\n.highlight .kc {\n  color: #000000;\n  font-weight: bold;\n}\n.highlight .kd {\n  color: #000000;\n  font-weight: bold;\n}\n.highlight .kn {\n  color: #000000;\n  font-weight: bold;\n}\n.highlight .kp {\n  color: #000000;\n  font-weight: bold;\n}\n.highlight .kr {\n  color: #000000;\n  font-weight: bold;\n}\n.highlight .kt {\n  color: #445588;\n  font-weight: bold;\n}\n.highlight .k, .highlight .kv {\n  color: #000000;\n  font-weight: bold;\n}\n.highlight .mf {\n  color: #009999;\n}\n.highlight .mh {\n  color: #009999;\n}\n.highlight .il {\n  color: #009999;\n}\n.highlight .mi {\n  color: #009999;\n}\n.highlight .mo {\n  color: #009999;\n}\n.highlight .m, .highlight .mb, .highlight .mx {\n  color: #009999;\n}\n.highlight .sb {\n  color: #d14;\n}\n.highlight .sc {\n  color: #d14;\n}\n.highlight .sd {\n  color: #d14;\n}\n.highlight .s2 {\n  color: #d14;\n}\n.highlight .se {\n  color: #d14;\n}\n.highlight .sh {\n  color: #d14;\n}\n.highlight .si {\n  color: #d14;\n}\n.highlight .sx {\n  color: #d14;\n}\n.highlight .sr {\n  color: #009926;\n}\n.highlight .s1 {\n  color: #d14;\n}\n.highlight .ss {\n  color: #990073;\n}\n.highlight .s, .highlight .sa, .highlight .dl {\n  color: #d14;\n}\n.highlight .na {\n  color: #008080;\n}\n.highlight .bp {\n  color: #999999;\n}\n.highlight .nb {\n  color: #0086B3;\n}\n.highlight .nc {\n  color: #445588;\n  font-weight: bold;\n}\n.highlight .no {\n  color: #008080;\n}\n.highlight .nd {\n  color: #3c5d5d;\n  font-weight: bold;\n}\n.highlight .ni {\n  color: #800080;\n}\n.highlight .ne {\n  color: #990000;\n  font-weight: bold;\n}\n.highlight .nf, .highlight .fm {\n  color: #990000;\n  font-weight: bold;\n}\n.highlight .nl {\n  color: #990000;\n  font-weight: bold;\n}\n.highlight .nn {\n  color: #555555;\n}\n.highlight .nt {\n  color: #000080;\n}\n.highlight .vc {\n  color: #008080;\n}\n.highlight .vg {\n  color: #008080;\n}\n.highlight .vi {\n  color: #008080;\n}\n.highlight .nv, .highlight .vm {\n  color: #008080;\n}\n.highlight .ow {\n  color: #000000;\n  font-weight: bold;\n}\n.highlight .o {\n  color: #000000;\n  font-weight: bold;\n}\n.highlight .w {\n  color: #bbbbbb;\n}\n.highlight {\n  background-color: #f8f8f8;\n}\n"
  },
  {
    "path": "public/css/hyde.css",
    "content": "/*\n *  __                  __\n * /\\ \\                /\\ \\\n * \\ \\ \\___   __  __   \\_\\ \\     __\n *  \\ \\  _ `\\/\\ \\/\\ \\  /'_` \\  /'__`\\\n *   \\ \\ \\ \\ \\ \\ \\_\\ \\/\\ \\_\\ \\/\\  __/\n *    \\ \\_\\ \\_\\/`____ \\ \\___,_\\ \\____\\\n *     \\/_/\\/_/`/___/> \\/__,_ /\\/____/\n *                /\\___/\n *                \\/__/\n *\n * Designed, built, and released under MIT license by @mdo. Learn more at\n * https://github.com/poole/hyde.\n */\n\n\n/*\n * Contents\n *\n * Global resets\n * Sidebar\n * Container\n * Reverse layout\n * Themes\n */\n\n\n/*\n * Global resets\n *\n * Update the foundational and global aspects of the page.\n */\n\nhtml {\n  font-family: \"PT Sans\", Helvetica, Arial, sans-serif;\n}\n@media (min-width: 48em) {\n  html {\n    font-size: 16px;\n  }\n}\n@media (min-width: 58em) {\n  html {\n    font-size: 20px;\n  }\n}\n\n\n/*\n * Sidebar\n *\n * Flexible banner for housing site name, intro, and \"footer\" content. Starts\n * out above content in mobile and later moves to the side with wider viewports.\n */\n\n.sidebar {\n  text-align: center;\n  padding: none;\n  color: rgba(255,255,255,.5);\n  background-color: #202020;\n}\n@media (min-width: 48em) {\n  .sidebar {\n    overflow-y: scroll;\n    position: fixed;\n    top: 0;\n    left: 0;\n    bottom: 0;\n    width: 18rem;\n    text-align: left;\n  }\n}\n\n/* Sidebar links */\n.sidebar a {\n  color: #fff;\n}\n\n/* About section */\n.sidebar-about h1 {\n  color: #fff;\n  margin-top: 0;\n  font-family: \"Abril Fatface\", serif;\n  font-size: 3.25rem;\n}\n\n/* Sidebar nav */\n.sidebar-nav {\n  margin-bottom: 1rem;\n}\n.sidebar-nav-item {\n  display: block;\n  line-height: 1.75;\n}\na.sidebar-nav-item:hover,\na.sidebar-nav-item:focus {\n  text-decoration: underline;\n}\n.sidebar-nav-item.active {\n  font-weight: bold;\n}\n\n/* Sticky sidebar\n *\n * Add the `sidebar-sticky` class to the sidebar's container to affix it the\n * contents to the bottom of the sidebar in tablets and up.\n */\n\n@media (min-width: 48em) {\n  .sidebar-sticky {\n    position: absolute;\n    right:  1rem;\n    bottom: 1rem;\n    left:   1rem;\n    top:    0rem;\n  }\n}\n\n\n/* Container\n *\n * Align the contents of the site above the proper threshold with some margin-fu\n * with a 25%-wide `.sidebar`.\n */\n\n.content {\n  padding-top:    4rem;\n  padding-bottom: 4rem;\n}\n\n@media (min-width: 48em) {\n  .content {\n    max-width: 38rem;\n    margin-left: 20rem;\n    margin-right: 2rem;\n  }\n}\n\n@media (min-width: 64em) {\n  .content {\n    margin-left: 22rem;\n    margin-right: 4rem;\n  }\n}\n\n\n/*\n * Reverse layout\n *\n * Flip the orientation of the page by placing the `.sidebar` on the right.\n */\n\n@media (min-width: 48em) {\n  .layout-reverse .sidebar {\n    left: auto;\n    right: 0;\n  }\n  .layout-reverse .content {\n    margin-left: 2rem;\n    margin-right: 20rem;\n  }\n}\n\n@media (min-width: 64em) {\n  .layout-reverse .content {\n    margin-left: 4rem;\n    margin-right: 22rem;\n  }\n}\n\n\n\n/*\n * Themes\n *\n * As of v1.1, Hyde includes optional themes to color the sidebar and links\n * within blog posts. To use, add the class of your choosing to the `body`.\n */\n\n/* Base16 (http://chriskempson.github.io/base16/#default) */\n\n/* Red */\n.theme-base-08 .sidebar {\n  background-color: #ac4142;\n}\n.theme-base-08 .content a,\n.theme-base-08 .related-posts li a:hover {\n  color: #ac4142;\n}\n\n/* Orange */\n.theme-base-09 .sidebar {\n  background-color: #d28445;\n}\n.theme-base-09 .content a,\n.theme-base-09 .related-posts li a:hover {\n  color: #d28445;\n}\n\n/* Yellow */\n.theme-base-0a .sidebar {\n  background-color: #f4bf75;\n}\n.theme-base-0a .content a,\n.theme-base-0a .related-posts li a:hover {\n  color: #f4bf75;\n}\n\n/* Green */\n.theme-base-0b .sidebar {\n  background-color: #90a959;\n}\n.theme-base-0b .content a,\n.theme-base-0b .related-posts li a:hover {\n  color: #90a959;\n}\n\n/* Cyan */\n.theme-base-0c .sidebar {\n  background-color: #75b5aa;\n}\n.theme-base-0c .content a,\n.theme-base-0c .related-posts li a:hover {\n  color: #75b5aa;\n}\n\n/* Blue */\n.theme-base-0d .sidebar {\n  background-color: #6a9fb5;\n}\n.theme-base-0d .content a,\n.theme-base-0d .related-posts li a:hover {\n  color: #6a9fb5;\n}\n\n/* Magenta */\n.theme-base-0e .sidebar {\n  background-color: #aa759f;\n}\n.theme-base-0e .content a,\n.theme-base-0e .related-posts li a:hover {\n  color: #aa759f;\n}\n\n/* Brown */\n.theme-base-0f .sidebar {\n  background-color: #8f5536;\n}\n.theme-base-0f .content a,\n.theme-base-0f .related-posts li a:hover {\n  color: #8f5536;\n}\n"
  },
  {
    "path": "public/css/poole.css",
    "content": "/*\n *                        ___\n *                       /\\_ \\\n *  _____     ___     ___\\//\\ \\      __\n * /\\ '__`\\  / __`\\  / __`\\\\ \\ \\   /'__`\\\n * \\ \\ \\_\\ \\/\\ \\_\\ \\/\\ \\_\\ \\\\_\\ \\_/\\  __/\n *  \\ \\ ,__/\\ \\____/\\ \\____//\\____\\ \\____\\\n *   \\ \\ \\/  \\/___/  \\/___/ \\/____/\\/____/\n *    \\ \\_\\\n *     \\/_/\n *\n * Designed, built, and released under MIT license by @mdo. Learn more at\n * https://github.com/poole/poole.\n */\n\n\n/*\n * Contents\n *\n * Body resets\n * Custom type\n * Messages\n * Container\n * Masthead\n * Posts and pages\n * Pagination\n * Reverse layout\n * Themes\n */\n\n\n/*\n * Body resets\n *\n * Update the foundational and global aspects of the page.\n */\n\n\nhtml,\nbody {\n  margin: 0;\n  padding: 0;\n}\n\nhtml {\n  font-family: \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n  font-size: 16px;\n  line-height: 1.5;\n}\n@media (min-width: 38em) {\n  html {\n    font-size: 20px;\n  }\n}\n\nbody {\n  color: #515151;\n  background-color: #fff;\n  -webkit-text-size-adjust: 100%;\n      -ms-text-size-adjust: 100%;\n}\n\n/* No `:visited` state is required by default (browsers will use `a`) */\na {\n  color: #268bd2;\n  text-decoration: none;\n}\na strong {\n  color: inherit;\n}\n/* `:focus` is linked to `:hover` for basic accessibility */\na:hover,\na:focus {\n  text-decoration: underline;\n}\n\n/* Headings */\nh1, h2, h3, h4, h5, h6 {\n  margin-bottom: .5rem;\n  font-weight: bold;\n  line-height: 1.25;\n  color: #313131;\n  text-rendering: optimizeLegibility;\n}\nh1 {\n  font-size: 2rem;\n}\nh2 {\n  margin-top: 1rem;\n  font-size: 1.5rem;\n}\nh3 {\n  margin-top: 1.5rem;\n  font-size: 1.25rem;\n}\nh4, h5, h6 {\n  margin-top: 1rem;\n  font-size: 1rem;\n}\n\n/* Body text */\np {\n  margin-top: 0;\n  margin-bottom: 1rem;\n}\n\nstrong {\n  color: #303030;\n}\n\n\n/* Lists */\nul, ol, dl {\n  margin-top: 0;\n  margin-bottom: 1rem;\n}\n\ndt {\n  font-weight: bold;\n}\ndd {\n  margin-bottom: .5rem;\n}\n\n/* Misc */\nhr {\n  position: relative;\n  margin: 1.5rem 0;\n  border: 0;\n  border-top: 1px solid #eee;\n  border-bottom: 1px solid #fff;\n}\n\nabbr {\n  font-size: 85%;\n  font-weight: bold;\n  color: #555;\n  text-transform: uppercase;\n}\nabbr[title] {\n  cursor: help;\n  border-bottom: 1px dotted #e5e5e5;\n}\n\n/* Code */\ncode,\npre {\n  font-family: \"Roboto Mono\", monospace;\n}\ncode {\n  padding: .2em .2em;\n  font-size: 90%;\n  background-color: #f9f9f9;\n  border-radius: 3px;\n}\n\n@media (max-width: 70em) {\n  code {\n      white-space: pre-wrap;\n      word-break: break-all;\n      word-wrap: break-word;\n  }\n}\npre {\n  display: block;\n  margin-top: 0;\n  font-size: .8rem;\n  line-height: 1.4;\n  background-color: #f9f9f9;\n}\n@media (min-width: 70em) {\n  pre {\n    display: inline-block;\n    min-width: 50em;\n    white-space: pre;\n  }\n}\n@media (min-width: 70em) {\n  pre code {\n    display: inline-block;\n    min-width: 50em;\n  }\n}\npre code {\n  padding: 0;\n  font-size: 100%;\n  color: black;\n  background-color: transparent;\n}\n\n/* Pygments via Jekyll */\n.highlight {\n  margin-bottom: 1rem;\n  border-radius: 4px;\n}\n.highlight pre {\n  margin-bottom: 0;\n}\n\n/* Gist via GitHub Pages */\n.gist .gist-file {\n  font-family: Menlo, Monaco, \"Courier New\", monospace !important;\n}\n.gist .markdown-body {\n  padding: 15px;\n}\n.gist pre {\n  padding: 0;\n  background-color: transparent;\n}\n.gist .gist-file .gist-data {\n  font-size: .8rem !important;\n  line-height: 1.4;\n}\n.gist code {\n  padding: 0;\n  color: inherit;\n  background-color: transparent;\n  border-radius: 0;\n}\n\n/* Quotes */\nblockquote {\n  padding: .5rem 1rem;\n  margin: .8rem 0;\n  color: #7a7a7a;\n  border-left: .25rem solid #e5e5e5;\n}\nblockquote p:last-child {\n  margin-bottom: 0;\n}\n@media (min-width: 30em) {\n  blockquote {\n    padding-right: 5rem;\n    padding-left: 1.25rem;\n  }\n}\n\nimg {\n  display: block;\n  max-width: 100%;\n  margin: 0 0 1rem;\n  border-radius: 5px;\n}\n\n/* Tables */\ntable {\n  margin-bottom: 1rem;\n  width: 100%;\n  border: 1px solid #e5e5e5;\n  border-collapse: collapse;\n}\ntd,\nth {\n  padding: .25rem .5rem;\n  border: 1px solid #e5e5e5;\n}\ntbody tr:nth-child(odd) td,\ntbody tr:nth-child(odd) th {\n  background-color: #f9f9f9;\n}\n\n\n/*\n * Custom type\n *\n * Extend paragraphs with `.lead` for larger introductory text.\n */\n\n.lead {\n  font-size: 1.25rem;\n  font-weight: 300;\n}\n\n\n/*\n * Messages\n *\n * Show alert messages to users. You may add it to single elements like a `<p>`,\n * or to a parent if there are multiple elements to show.\n */\n\n.message {\n  margin-bottom: 1rem;\n  padding: 1rem;\n  color: #717171;\n  background-color: #f9f9f9;\n}\n\n\n/*\n * Container\n *\n * Center the page content.\n */\n\n.container {\n  max-width: 38rem;\n  padding-left:  1rem;\n  padding-right: 1rem;\n  margin-left:  auto;\n  margin-right: auto;\n}\n\n\n/*\n * Masthead\n *\n * Super small header above the content for site name and short description.\n */\n\n.masthead {\n  padding-top:    1rem;\n  padding-bottom: 1rem;\n  margin-bottom: 3rem;\n}\n.masthead-title {\n  margin-top: 0;\n  margin-bottom: 0;\n  color: #505050;\n}\n.masthead-title a {\n  color: #505050;\n}\n.masthead-title small {\n  font-size: 75%;\n  font-weight: 400;\n  color: #c0c0c0;\n  letter-spacing: 0;\n}\n\n\n/*\n * Posts and pages\n *\n * Each post is wrapped in `.post` and is used on default and post layouts. Each\n * page is wrapped in `.page` and is only used on the page layout.\n */\n\n.page,\n.post {\n  margin-bottom: 4em;\n}\n\n/* Blog post or page title */\n.page-title,\n.post-title,\n.post-title a {\n  color: #303030;\n}\n.page-title,\n.post-title {\n  margin-top: 0;\n}\n\n/* Meta data line below post title */\n.post-date {\n  display: block;\n  margin-top: -.5rem;\n  margin-bottom: 1rem;\n  color: #9a9a9a;\n}\n\n/* Related posts */\n.related {\n  padding-top: 2rem;\n  padding-bottom: 2rem;\n  border-top: 1px solid #eee;\n}\n.related-posts {\n  padding-left: 0;\n  list-style: none;\n}\n.related-posts h3 {\n  margin-top: 0;\n}\n.related-posts li small {\n  font-size: 75%;\n  color: #999;\n}\n.related-posts li a:hover {\n  color: #268bd2;\n  text-decoration: none;\n}\n.related-posts li a:hover small {\n  color: inherit;\n}\n\n\n/*\n * Pagination\n *\n * Super lightweight (HTML-wise) blog pagination. `span`s are provide for when\n * there are no more previous or next posts to show.\n */\n\n.pagination {\n  overflow: hidden; /* clearfix */\n  margin-left: -1rem;\n  margin-right: -1rem;\n  font-family: \"PT Sans\", Helvetica, Arial, sans-serif;\n  color: #ccc;\n  text-align: center;\n}\n\n/* Pagination items can be `span`s or `a`s */\n.pagination-item {\n  display: block;\n  padding: 1rem;\n  border: 1px solid #eee;\n}\n.pagination-item:first-child {\n  margin-bottom: -1px;\n}\n\n/* Only provide a hover state for linked pagination items */\na.pagination-item:hover {\n  background-color: #f5f5f5;\n}\n\n@media (min-width: 30em) {\n  .pagination {\n    margin: 3rem 0;\n  }\n  .pagination-item {\n    float: left;\n    width: 50%;\n  }\n  .pagination-item:first-child {\n    margin-bottom: 0;\n    border-top-left-radius:    4px;\n    border-bottom-left-radius: 4px;\n  }\n  .pagination-item:last-child {\n    margin-left: -1px;\n    border-top-right-radius:    4px;\n    border-bottom-right-radius: 4px;\n  }\n}\n"
  },
  {
    "path": "scripts/Makefile",
    "content": "# This Makefile is supposed to run on the Travis CI server and also locally\n# it assumes the nodejs package managaer npm is installed\n\n# make magic not needed\nMAKEFLAGS += --no-builtin-rules\n.SUFFIXES:\n\nBUILD_DIR=build\nSOURCEFILE = CppCoreGuidelines.md\nSOURCEPATH = ../$(SOURCEFILE)\n\n.PHONY: default\ndefault: all\n\n.PHONY: all\nall: \\\ncheck-markdown \\\ncheck-references \\\ncheck-notabs \\\nhunspell-check \\\ncpplint-all \\\ncheck-badchars\n\n$(BUILD_DIR):\n\t@mkdir -p $(BUILD_DIR)\n\n#### clean: remove all files generated by the productive rules\n.PHONY: clean\nclean:\n\trm -rf $(BUILD_DIR)\n\n#### distclean: remove all helper executables that may be downloaded by the Makefile\n.PHONY: distclean\ndistclean:\n\trm -rf ./nodejs/node_modules\n\n\n#### check markdown\n\n## run remark markdown checker based on configuration in .remarkrc\n.PHONY: check-markdown\ncheck-markdown: nodejs/node_modules/remark nodejs/remark/.remarkrc $(SOURCEPATH) $(BUILD_DIR) Makefile\n\techo '##################### Markdown check ##################'\n## run remark, paste output to temporary file\n\tcd nodejs; ./node_modules/.bin/remark ../$(SOURCEPATH) --no-color -q --config-path ./remark/.remarkrc 1> ../$(BUILD_DIR)/$(SOURCEFILE).fixed --frail\n\n## show a diff with changes remark suggests\n.PHONY: show-diff\nshow-diff: nodejs/node_modules/remark nodejs/remark/.remarkrc $(SOURCEPATH) $(BUILD_DIR) Makefile\n\tcd nodejs; ./node_modules/.bin/remark ../$(SOURCEPATH) --no-color -q --config-path ./remark/.remarkrc 1> ../$(BUILD_DIR)/$(SOURCEFILE).fixed\n## compare temporary file to original, error and fail with message if differences exist\n\tdiff $(SOURCEPATH) $(BUILD_DIR)/$(SOURCEFILE).fixed -u3 || \\\n\t(echo \"Error: remark found bad markdown syntax, see output above\" && false)\n\n\n.PHONY: check-references\ncheck-references: $(SOURCEPATH) $(BUILD_DIR) Makefile\n\t@echo '##################### References check ##################'\n## check references unique\n\t@rm -f $(BUILD_DIR)/$(SOURCEFILE).uniq\n\t@cat $(SOURCEPATH) | perl -ne 'print \"$$1\\n\" if (/<a name=\"([^\\\"]+)/)' | sort | uniq -d > $(BUILD_DIR)/$(SOURCEFILE).uniq\n## check if output has data\n\t@if [ -s \"build/CppCoreGuidelines.md.uniq\" ]; then echo 'Found duplicate anchors:'; cat $(BUILD_DIR)/$(SOURCEFILE).uniq; false; fi\n\n.PHONY: check-notabs\ncheck-notabs: $(SOURCEPATH) $(BUILD_DIR) Makefile\n\t@echo '##################### Tabs check ##################'\n# find lines with tabs\n# old file still might be around\n\t@rm -f $(BUILD_DIR)/CppCoreGuidelines.md.tabs\n# print file, add line numbers, remove tabs from nl tool, grep for remaining tabs, replace with stars\n\t@cat ../$(SOURCEFILE) | nl -ba | perl -pe 's/(^[^\\t]*)\\t/$1--/g' | perl -ne 'print if /\\t/' | perl -pe 's/\\t/\\*\\*\\*\\*/g' > $(BUILD_DIR)/$(SOURCEFILE).tabs\n\t@if [ -s $(BUILD_DIR)/CppCoreGuidelines.md.tabs ]; then echo 'Warning: Tabs found:'; cat $(BUILD_DIR)/CppCoreGuidelines.md.tabs; false; fi;\n\n.PHONY: check-badchars\ncheck-badchars: $(SOURCEPATH) $(BUILD_DIR) Makefile\n\t@echo '##################### Bad chars check ##################'\n# find lines with tabs\n# old file still might be around\n\t@rm -f $(BUILD_DIR)/CppCoreGuidelines.md.badchars\n# print file, add line numbers, grep for bad chars\n\t@cat ../$(SOURCEFILE) | nl -ba | perl -ne 'print if /’|‘|”|“|¸| |–|…|¦/' > $(BUILD_DIR)/$(SOURCEFILE).badchars || true\n\t@if [ -s $(BUILD_DIR)/CppCoreGuidelines.md.badchars ]; then echo 'Warning: Undesired chars (–’‘“”¸…¦) or Unicode EN SPACE found, use markdown-compatible symbols instead:'; cat $(BUILD_DIR)/CppCoreGuidelines.md.badchars; false; fi;\n\n\n.PHONY: hunspell-check\nhunspell-check: $(BUILD_DIR)/plain-nohtml.txt\n\t@echo '##################### Spell check ##################'\n\tsed -e 's!http\\(s\\)\\{0,1\\}://[^[:space:]]*!!g' build/plain-nohtml.txt | hunspell -d hunspell/en_US -p hunspell/isocpp.dic -u  > $(BUILD_DIR)/hunspell-report.txt\n\t@if [ -s $(BUILD_DIR)/hunspell-report.txt ]; then echo 'Warning: Spellcheck failed, fix words or add to dictionary:'; cat $(BUILD_DIR)/hunspell-report.txt; false; fi;\n\n# only list words that are not in dict\n# to include all add them to bottom of hunspell/isocpp.dict, and run\n# cat hunspell/isocpp.dic | sort | uniq > hunspell/isocpp.dic2; mv hunspell/isocpp.dic2 hunspell/isocpp.dic\n.PHONY: hunspell-list\nhunspell-list: $(BUILD_DIR)/plain.txt\n\tsed -e 's!http\\(s\\)\\{0,1\\}://[^[:space:]]*!!g' build/plain-nohtml.txt | hunspell -p hunspell/isocpp.dic -l\n\n#### Cpplint\n\n.PHONY: cpplint-all\ncpplint-all: $(BUILD_DIR)/codeblocks $(BUILD_DIR)/Makefile python/Makefile.in\n\t@echo '##################### C++ Style check ##################'\n\tcd $(BUILD_DIR)/codeblocks; $(MAKE) cpplint-all -k\n\n#### generic makefile for sourceblocks (need to be evaluated after c++ file generation)\n\n$(BUILD_DIR)/Makefile: python/Makefile.in\n\t@cp python/Makefile.in $(BUILD_DIR)/codeblocks/Makefile\n\n#### split md file into plain text and code\n\n$(BUILD_DIR)/codeblocks: splitfile\n\n$(BUILD_DIR)/plain.txt: splitfile\n\n$(BUILD_DIR)/plain-nohtml.txt: $(BUILD_DIR)/plain.txt\n\tsed 's;<a \\(name\\|href\\)=\".*</a>;;g' $(BUILD_DIR)/plain.txt > $(BUILD_DIR)/plain-nohtml.txt\n\n.PHONY: splitfile\nsplitfile: $(SOURCEPATH) ./python/md-split.py\n\t@python ./python/md-split.py $(SOURCEPATH) $(BUILD_DIR)/plain.txt $(BUILD_DIR)/codeblocks\n\n#### install npm modules\n# install/update npm dependencies defined in file package.json\n# requires npm (nodejs package manager)\nnodejs/node_modules/%: nodejs/package.json\n\t@cd nodejs; npm install\n"
  },
  {
    "path": "scripts/hunspell/en_US.aff",
    "content": "SET ISO8859-1\nKEY qwertyuiop|asdfghjkl|zxcvbnm\nTRY esianrtolcdugmphbyfvkwzESIANRTOLCDUGMPHBYFVKWZ'-\nNOSUGGEST !\n\n# ordinal numbers (1st, 2nd, 3th, 11th) and decads (0s, 10s, 1990s)\nCOMPOUNDMIN 1\n# only in compounds: 1th, 2th, 3th\nONLYINCOMPOUND c\n# compound rules:\n# 1. [0-9]*1[0-9]th (10th, 11th, 12th, 56714th, etc.)\n# 2. [0-9]*[02-9](1st|2nd|3rd|[4-9]th) (21st, 22nd, 123rd, 1234th, etc.)\nCOMPOUNDRULE 2\nCOMPOUNDRULE n*1t\nCOMPOUNDRULE n*mp\nWORDCHARS 0123456789'\n\nPFX A Y 1\nPFX A   0     re         .\n\nPFX I Y 1\nPFX I   0     in         .\n\nPFX U Y 1\nPFX U   0     un         .\n\nPFX C Y 1\nPFX C   0     de          .\n\nPFX E Y 1\nPFX E   0     dis         .\n\nPFX F Y 1\nPFX F   0     con         .\n\nPFX K Y 1\nPFX K   0     pro         .\n\nSFX V N 2\nSFX V   e     ive        e\nSFX V   0     ive        [^e]\n\nSFX N Y 3\nSFX N   e     ion        e\nSFX N   y     ication    y \nSFX N   0     en         [^ey] \n\nSFX X Y 3\nSFX X   e     ions       e\nSFX X   y     ications   y\nSFX X   0     ens        [^ey]\n\nSFX H N 2\nSFX H   y     ieth       y\nSFX H   0     th         [^y] \n\nSFX Y Y 1\nSFX Y   0     ly         .\n\nSFX G Y 2\nSFX G   e     ing        e\nSFX G   0     ing        [^e] \n\nSFX J Y 2\nSFX J   e     ings       e\nSFX J   0     ings       [^e]\n\nSFX D Y 4\nSFX D   0     d          e\nSFX D   y     ied        [^aeiou]y\nSFX D   0     ed         [^ey]\nSFX D   0     ed         [aeiou]y\n\nSFX T N 4\nSFX T   0     st         e\nSFX T   y     iest       [^aeiou]y\nSFX T   0     est        [aeiou]y\nSFX T   0     est        [^ey]\n\nSFX R Y 4\nSFX R   0     r          e\nSFX R   y     ier        [^aeiou]y\nSFX R   0     er         [aeiou]y\nSFX R   0     er         [^ey]\n\nSFX Z Y 4\nSFX Z   0     rs         e\nSFX Z   y     iers       [^aeiou]y\nSFX Z   0     ers        [aeiou]y\nSFX Z   0     ers        [^ey]\n\nSFX S Y 4\nSFX S   y     ies        [^aeiou]y\nSFX S   0     s          [aeiou]y\nSFX S   0     es         [sxzh]\nSFX S   0     s          [^sxzhy]\n\nSFX P Y 3\nSFX P   y     iness      [^aeiou]y\nSFX P   0     ness       [aeiou]y\nSFX P   0     ness       [^y]\n\nSFX M Y 1\nSFX M   0     's         .\n\nSFX B Y 3\nSFX B   0     able       [^aeiou]\nSFX B   0     able       ee\nSFX B   e     able       [^aeiou]e\n\nSFX L Y 1\nSFX L   0     ment       .\n\nREP 97\nREP nt n't\nREP alot a_lot\nREP avengence a_vengeance\nREP ninties 1990s\nREP teached taught\nREP rised rose\nREP a ei\nREP ei a\nREP a ey\nREP ey a\nREP ai ie\nREP ie ai\nREP are air\nREP are ear\nREP are eir\nREP air are\nREP air ere\nREP ere air\nREP ere ear\nREP ere eir\nREP ear are\nREP ear air\nREP ear ere\nREP eir are\nREP eir ere\nREP ch te\nREP te ch\nREP ch ti\nREP ti ch\nREP ch tu\nREP tu ch\nREP ch s\nREP s ch\nREP ch k\nREP k ch\nREP f ph\nREP ph f\nREP gh f\nREP f gh\nREP i igh\nREP igh i\nREP i uy\nREP uy i\nREP i ee\nREP ee i\nREP j di\nREP di j\nREP j gg\nREP gg j\nREP j ge\nREP ge j\nREP s ti\nREP ti s\nREP s ci\nREP ci s\nREP k cc\nREP cc k\nREP k qu\nREP qu k\nREP kw qu\nREP o eau\nREP eau o\nREP o ew\nREP ew o\nREP oo ew\nREP ew oo\nREP ew ui\nREP ui ew\nREP oo ui\nREP ui oo\nREP ew u\nREP u ew\nREP oo u\nREP u oo\nREP u oe\nREP oe u\nREP u ieu\nREP ieu u\nREP ue ew\nREP ew ue\nREP uff ough\nREP oo ieu\nREP ieu oo\nREP ier ear\nREP ear ier\nREP ear air\nREP air ear\nREP w qu\nREP qu w\nREP z ss\nREP ss z\nREP shun tion\nREP shun sion\nREP shun cion\nREP tion ssion\nREP ys ies\nREP u ough\n\n#   PHONEtic_english.h - #PHONEtic transformation rules for use with #PHONEtic.c\n#   Copyright (C) 2000 Bjrn Jacke\n#\n#   This rule set is based on Lawrence Phillips original metaPHONE \n#   algorithm with modifications made by Michael Kuhn in his\n#   C implantation, more modifications by Bjrn Jacke when\n#   converting the algorithm to a rule set and minor \n#   touch ups by Kevin Atkinson\n#\n#   This library is free software; you can redistribute it and/or\n#   modify it under the terms of the GNU Lesser General Public\n#   License version 2.1 as published by the Free Software Foundation;\n#\n#   This library is distributed in the hope that it will be useful,\n#   but WITHOUT ANY WARRANTY; without even the implied warranty of\n#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n#   Lesser General Public License for more details.\n#\n#   You should have received a copy of the GNU Lesser General Public\n#   License along with this library; if not, write to the Free Software\n#   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n#\n#   Bjrn Jacke may be reached by email at bjoern.jacke@gmx.de\n#\n#   Changelog:\n#\n#   2000-01-05  Bjrn Jacke <bjoern.jacke@gmx.de>\n#               - first version with translation rules derived from\n#                 metaPHONE.cc distributed with aspell 0.28.3\n#               - \"TH\" is now representated as \"@\" because \"0\" is a\n#                 meta character\n#               - removed TH(!vowel) --> T; always use TH --> # instead\n#               - dropped \"^AE\" -> \"E\" (redundant)\n#               - \"ing\" is transformed to \"N\", not \"NK\"\n#               - \"SCH(EO)\" transforms to \"SK\" now\n#               - added R --> SILENT if (after a vowel) and no (vowel or\n#                 \"y\" follows) like in \"Marcy\" or \"abort\"\n#               - H is SILENT in RH at beginning of words\n#               - H is SILENT if vowel leads and \"Y\" follows\n#               - some \".OUGH..\"  --> ...F exceptions added\n#               - \"^V\" transforms to \"W\"\n#   2000-01-07  Kevin Atkinson <kevinatk@home.com>\n#               Converted from header to data file.\n#\n#   2007-08-23  László Németh <nemeth AT OOo>\n#               Add PHONE header and #PHONE keywords\n#\n# version 1.1\n\n# Documentation: http://aspell.net/man-html/PHONEtic-Code.html\n\nPHONE 105\nPHONE AH(AEIOUY)-^         *H\nPHONE AR(AEIOUY)-^         *R\nPHONE A(HR)^               *\nPHONE A^                   *\nPHONE AH(AEIOUY)-          H\nPHONE AR(AEIOUY)-          R\nPHONE A(HR)                _\nPHONE BB-                  _\nPHONE B                    B\nPHONE CQ-                  _\nPHONE CIA                  X\nPHONE CH                   X\nPHONE C(EIY)-              S\nPHONE CK                   K\nPHONE COUGH^               KF\nPHONE CC<                  C\nPHONE C                    K\nPHONE DG(EIY)              K\nPHONE DD-                  _\nPHONE D                    T\nPHONE <                   E\nPHONE EH(AEIOUY)-^         *H\nPHONE ER(AEIOUY)-^         *R\nPHONE E(HR)^               *\nPHONE ENOUGH^$             *NF\nPHONE E^                   *\nPHONE EH(AEIOUY)-          H\nPHONE ER(AEIOUY)-          R\nPHONE E(HR)                _\nPHONE FF-                  _\nPHONE F                    F\nPHONE GN^                  N\nPHONE GN$                  N\nPHONE GNS$                 NS\nPHONE GNED$                N\nPHONE GH(AEIOUY)-          K\nPHONE GH                   _\nPHONE GG9                  K\nPHONE G                    K\nPHONE H                    H\nPHONE IH(AEIOUY)-^         *H\nPHONE IR(AEIOUY)-^         *R\nPHONE I(HR)^               *\nPHONE I^                   *\nPHONE ING6                 N\nPHONE IH(AEIOUY)-          H\nPHONE IR(AEIOUY)-          R\nPHONE I(HR)                _\nPHONE J                    K\nPHONE KN^                  N\nPHONE KK-                  _\nPHONE K                    K\nPHONE LAUGH^               LF\nPHONE LL-                  _\nPHONE L                    L\nPHONE MB$                  M\nPHONE MM                   M\nPHONE M                    M\nPHONE NN-                  _\nPHONE N                    N\nPHONE OH(AEIOUY)-^         *H\nPHONE OR(AEIOUY)-^         *R\nPHONE O(HR)^               *\nPHONE O^                   *\nPHONE OH(AEIOUY)-          H\nPHONE OR(AEIOUY)-          R\nPHONE O(HR)                _\nPHONE PH                   F\nPHONE PN^                  N\nPHONE PP-                  _\nPHONE P                    P\nPHONE Q                    K\nPHONE RH^                  R\nPHONE ROUGH^               RF\nPHONE RR-                  _\nPHONE R                    R\nPHONE SCH(EOU)-            SK\nPHONE SC(IEY)-             S\nPHONE SH                   X\nPHONE SI(AO)-              X\nPHONE SS-                  _\nPHONE S                    S\nPHONE TI(AO)-              X\nPHONE TH                   @\nPHONE TCH--                _\nPHONE TOUGH^               TF\nPHONE TT-                  _\nPHONE T                    T\nPHONE UH(AEIOUY)-^         *H\nPHONE UR(AEIOUY)-^         *R\nPHONE U(HR)^               *\nPHONE U^                   *\nPHONE UH(AEIOUY)-          H\nPHONE UR(AEIOUY)-          R\nPHONE U(HR)                _\nPHONE V^                   W\nPHONE V                    F\nPHONE WR^                  R\nPHONE WH^                  W\nPHONE W(AEIOU)-            W\nPHONE X^                   S\nPHONE X                    KS\nPHONE Y(AEIOU)-            Y\nPHONE ZZ-                  _\nPHONE Z                    S\n\n#The rules in a different view:\n#\n# Exceptions:\n#\n#  Beginning of word: \"gn\", \"kn-\", \"pn-\", \"wr-\"  ----> drop first letter\n#                     \"Aebersold\", \"Gnagy\", \"Knuth\", \"Pniewski\", \"Wright\"\n#\n#  Beginning of word: \"x\"                                ----> change to \"s\"\n#                                     as in \"Deng Xiaopeng\"\n#\n#  Beginning of word: \"wh-\"                              ----> change to \"w\"\n#                                     as in \"Whalen\"\n#  Beginning of word: leading vowels are transformed to \"*\"\n#\n#  \"[crt]ough\" and \"enough\" are handled separately because of \"F\" sound\n#\n#\n#  A --> A      at beginning\n#          _      otherwise\n#\n#  B --> B      unless at the end of word after \"m\", as in \"dumb\", \"McComb\"\n#\n#  C --> X      (sh) if \"-cia-\" or \"-ch-\"\n#          S      if \"-ci-\", \"-ce-\", or \"-cy-\"\n#                 SILENT if \"-sci-\", \"-sce-\", or \"-scy-\", or \"-cq-\"\n#          K      otherwise, including in \"-sch-\"\n#\n#  D --> K      if in \"-dge-\", \"-dgy-\", or \"-dgi-\"\n#          T      otherwise\n#\n#  E --> A      at beginnig\n#          _      SILENT otherwise\n#  \n#  F --> F\n#\n#  G -->        SILENT if in \"-gh-\" and not at end or before a vowel\n#                            in \"-gn\" or \"-gned\" or \"-gns\"\n#                           in \"-dge-\" etc., as in above rule\n#          K      if before \"i\", or \"e\", or \"y\" if not double \"gg\"\n#\n#          K      otherwise (incl. \"GG\"!)\n#\n#  H -->        SILENT if after vowel and no vowel or \"Y\" follows\n#                        or after \"-ch-\", \"-sh-\", \"-ph-\", \"-th-\", \"-gh-\"\n#                        or after \"rh-\" at beginning\n#          H      otherwise\n#\n#  I --> A      at beginning\n#          _      SILENT otherwise\n#\n#  J --> K\n#\n#  K -->        SILENT if after \"c\"\n#          K      otherwise\n#\n#  L --> L\n#\n#  M --> M\n#  \n#  N --> N\n#\n#  O --> A      at beginning\n#          _      SILENT otherwise\n#\n#  P --> F      if before \"h\"\n#          P      otherwise\n#\n#  Q --> K\n#\n#  R -->        SILENT if after vowel and no vowel or \"Y\" follows\n#          R      otherwise\n#\n#  S --> X      (sh) if before \"h\" or in \"-sio-\" or \"-sia-\"\n#          SK     if followed by \"ch(eo)\" (SCH(EO))\n#          S      otherwise\n#\n#  T --> X      (sh) if \"-tia-\" or \"-tio-\"\n#          0      (th) if before \"h\"\n#                 silent if in \"-tch-\"\n#          T      otherwise\n#\n#  U --> A      at beginning\n#          _      SILENT otherwise\n#\n#  V --> V      if first letter of word\n#          F      otherwise\n#\n#  W -->        SILENT if not followed by a vowel\n#          W      if followed by a vowel\n#\n#  X --> KS\n#\n#  Y -->        SILENT if not followed by a vowel\n#          Y      if followed by a vowel\n# \n#  Z --> S\n"
  },
  {
    "path": "scripts/hunspell/en_US.dic",
    "content": "62154\n0/nm\n0s/pt\n0th/pt\n1/n1\n1990s\n1st/p\n1th/tc\n2/nm\n2nd/p\n2th/tc\n3/nm\n3rd/p\n3th/tc\n4/nm\n4th/pt\n5/nm\n5th/pt\n6/nm\n6th/pt\n7/nm\n7th/pt\n8/nm\n8th/pt\n9/nm\n9th/pt\nA\nA's\nAA\nAAA\nAB\nABC/M\nABM/S\nABS\nAC\nACLU\nACM\nACT\nACTH\nAD\nADC\nADP\nAF\nAFAIK\nAFB\nAFC\nAFDC\nAI\nAIDS\nAK\nAL\nALGOL\nALU\nAM\nAMA\nANSI/M\nAOL/M\nAP\nAPB\nAPO\nAPR\nAR\nARC\nARCO/M\nARPA/M\nARPANET/M\nASAP\nASCII\nASL\nASPCA\nATM/M\nATP\nATV/S\nAV\nAWACS\nAWOL\nAZ\nAZT\nAachen/M\nAaren/M\nAarhus/M\nAarika/M\nAaron/M\nAb/M\nAbagael/M\nAbagail/M\nAbba/M\nAbbe/M\nAbbey/M\nAbbi/M\nAbbie/M\nAbbot/M\nAbbott/M\nAbby/M\nAbbye/M\nAbdel/M\nAbdul/M\nAbe/M\nAbel/M\nAbelard/M\nAbelson/M\nAberdeen/M\nAbernathy/M\nAbeu/M\nAbey/M\nAbidjan/M\nAbie/M\nAbigael/M\nAbigail/M\nAbigale/M\nAbilene/M\nAbner/M\nAbo/SM!\nAborigine/SM\nAbra/M\nAbraham/M\nAbrahan/M\nAbram/SM\nAbramo/M\nAbramson/M\nAbran/M\nAbuja\nAbyssinia/M\nAbyssinian\nAc/M\nAcadia/M\nAcapulco/M\nAccra/M\nAcevedo/M\nAchaean/M\nAchebe/M\nAchernar/M\nAcheson/M\nAchilles\nAckerman/M\nAconcagua/M\nAcosta/M\nAcropolis/M\nAcrux/M\nActa/M\nActaeon/M\nActon/M\nActs\nAd/MN\nAda/M\nAdah/M\nAdair/M\nAdaline/M\nAdam/SM\nAdamo/M\nAdamson/M\nAdan/M\nAdana/M\nAdara/M\nAdda/M\nAddams\nAddi/M\nAddia/M\nAddie/M\nAddison/M\nAddressograph/M\nAddy/M\nAde/M\nAdel/M\nAdela/M\nAdelaida/M\nAdelaide/M\nAdelbert/M\nAdele/M\nAdelheid/M\nAdelice/M\nAdelina/M\nAdelind/M\nAdeline/M\nAdella/M\nAdelle/M\nAden/M\nAdena/M\nAdenauer/M\nAdey/M\nAdham/M\nAdhara/M\nAdi/M\nAdiana/M\nAdidas/M\nAdina/M\nAdirondack/SM\nAdkins/M\nAdlai/M\nAdler/M\nAdm/M\nAdmiralty/S\nAdo/M\nAdolf/M\nAdolfo/M\nAdolph/M\nAdolphe/M\nAdolpho/M\nAdolphus/M\nAdonis/SM\nAdora/M\nAdore/M\nAdoree/M\nAdorne/M\nAdrea/M\nAdrenalin/MS\nAdria/MX\nAdrian/M\nAdriana/M\nAdriane/M\nAdrianna/M\nAdrianne/M\nAdriano/M\nAdriatic\nAdrien/M\nAdriena/M\nAdrienne/M\nAdvent/SM\nAdventist/M\nAdvil/M\nAegean\nAelfric/M\nAeneas\nAeneid/M\nAeolus/M\nAeriel/M\nAeriela/M\nAeriell/M\nAeschylus/M\nAesculapius/M\nAesop/M\nAfghan/SM\nAfghani/SM\nAfghanistan/M\nAfr\nAfrica/M\nAfrican/MS\nAfrikaans/M\nAfrikaner/SM\nAfro/MS\nAfrocentric\nAfrocentrism/S\nAfton/M\nAg/M\nAgace/M\nAgamemnon/M\nAgassiz/M\nAgata/M\nAgatha/M\nAgathe/M\nAggi/M\nAggie/M\nAggy/SM\nAglaia/M\nAgna/M\nAgnella/M\nAgnes/M\nAgnese/M\nAgnesse/M\nAgneta/M\nAgnew/M\nAgni/M\nAgnola/M\nAgosto/M\nAgra/M\nAgretha/M\nAgricola/M\nAgrippa/M\nAgrippina/M\nAguascalientes/M\nAguie/M\nAguilar/M\nAguinaldo/M\nAguirre/M\nAguistin/M\nAguste/M\nAgustin/M\nAhab/M\nAharon/M\nAhmad/M\nAhmadabad\nAhmed/M\nAhriman/M\nAida/M\nAidan/M\nAigneis/M\nAiken/M\nAila/M\nAilbert/M\nAile/M\nAilee/M\nAileen/M\nAilene/M\nAiley/M\nAili/SM\nAilina/M\nAilsun/M\nAilyn/M\nAime/M\nAimee/M\nAimil/M\nAindrea/M\nAinslee/M\nAinsley/M\nAinslie/M\nAinu/M\nAirbus/M\nAiredale/SM\nAires\nAisha/M\nAjax/M\nAjay/M\nAkbar/M\nAkihito/M\nAkim/M\nAkita/M\nAkkad/M\nAkron/M\nAksel/M\nAl/MRY\nAla/MS\nAlabama/M\nAlabaman/S\nAlabamian/MS\nAladdin/M\nAlain/M\nAlaine/M\nAlair/M\nAlameda/M\nAlamo/SM\nAlamogordo/M\nAlan/M\nAlana/M\nAlanah/M\nAland/M\nAlane/M\nAlanna/M\nAlano/M\nAlanson/M\nAlar/M\nAlard/M\nAlaric/M\nAlasdair/M\nAlaska/M\nAlaskan/S\nAlastair/M\nAlasteir/M\nAlaster/M\nAlayne/M\nAlba/M\nAlbania/M\nAlbanian/SM\nAlbany/M\nAlbee/M\nAlberich/M\nAlberik/M\nAlberio/M\nAlbert/M\nAlberta/M\nAlbertan/S\nAlbertina/M\nAlbertine/M\nAlberto/M\nAlbie/M\nAlbigensian\nAlbina/M\nAlbion/M\nAlbireo/M\nAlbrecht/M\nAlbuquerque/M\nAlcatraz/M\nAlcestis/M\nAlcibiades/M\nAlcmena/M\nAlcoa/M\nAlcott/M\nAlcuin/M\nAlcyone/M\nAldan/M\nAldebaran/M\nAlden/M\nAlderamin/M\nAldin/M\nAldis/M\nAldo/M\nAldon/M\nAldous/M\nAldric/M\nAldrich/M\nAldridge/M\nAldrin/M\nAldus/M\nAldwin/M\nAlec/M\nAlecia/M\nAleck/M\nAleda/M\nAleece/M\nAleen/M\nAleichem/M\nAlejandra/M\nAlejandrina/M\nAlejandro/M\nAlejoa/M\nAleksandr/M\nAlembert/M\nAlena/M\nAlene/M\nAleppo/M\nAler/M\nAlessandra/M\nAlessandro/M\nAleta/M\nAlethea/M\nAleut/SM\nAleutian/S\nAlex/M\nAlexa/M\nAlexander/SM\nAlexandr/M\nAlexandra/M\nAlexandre/M\nAlexandria/M\nAlexandrian/S\nAlexandrina/M\nAlexandro/MS\nAlexei/M\nAlexi/SM\nAlexia/M\nAlexina/M\nAlexine/M\nAlexio/M\nAlf/M\nAlfa/M\nAlfi/M\nAlfie/M\nAlfons/M\nAlfonse/M\nAlfonso/M\nAlfonzo/M\nAlford/M\nAlfred/M\nAlfreda/M\nAlfredo/M\nAlfy/M\nAlgenib/M\nAlger/M\nAlgeria/M\nAlgerian/MS\nAlgernon/M\nAlgieba/M\nAlgiers/M\nAlgol/M\nAlgonquian/SM\nAlgonquin/SM\nAlhambra/M\nAlhena/M\nAli/MS\nAlia/M\nAlic/M\nAlica/M\nAlice/M\nAlicea/M\nAlicia/M\nAlick/M\nAlida/M\nAlidia/M\nAlie/M\nAlighieri/M\nAlika/M\nAlikee/M\nAlina/M\nAline/M\nAlioth/M\nAlisa/M\nAlisander/M\nAlisha/M\nAlison/M\nAlissa/M\nAlistair/M\nAlister/M\nAlisun/M\nAlix/M\nAliza/M\nAlkaid/M\nAlla/M\nAllah/M\nAllahabad/M\nAllan/M\nAllard/M\nAllayne/M\nAlleen/M\nAllegheny/MS\nAllegra/M\nAllen/M\nAllendale/M\nAllende/M\nAllene/M\nAllentown/M\nAlley/M\nAlleyn/M\nAllhallows\nAlli/MS\nAllianora/M\nAllie/M\nAllin/M\nAllina/M\nAllison/M\nAllissa/M\nAllister/M\nAllistir/M\nAllix/M\nAllstate/M\nAllsun/M\nAllx/M\nAlly/MS\nAllyce/M\nAllyn/M\nAllys\nAllyson/M\nAlma/M\nAlmach/M\nAlmaden/M\nAlmaty/M\nAlmeda/M\nAlmeria/M\nAlmeta/M\nAlmighty/M\nAlmira/M\nAlmire/M\nAlnilam/M\nAlnitak/M\nAloin/M\nAloise/M\nAloisia/M\nAlon/M\nAlonso/M\nAlonzo/M\nAloysia/M\nAloysius/M\nAlpert/M\nAlphard/M\nAlphecca/M\nAlpheratz/M\nAlphonse/M\nAlphonso/M\nAlpine\nAlps\nAlric/M\nAlsace/M\nAlsatian/MS\nAlsop/M\nAlston/M\nAlta/M\nAltai/M\nAltaic/M\nAltair/M\nAlthea/M\nAltiplano/M\nAlton/M\nAltos/M\nAludra/M\nAluin/M\nAluino/M\nAlva/M\nAlvan/M\nAlvarado/M\nAlvarez/M\nAlvaro/M\nAlvera/M\nAlverta/M\nAlvie/M\nAlvin/M\nAlvina/M\nAlvinia/M\nAlvira/M\nAlvis/M\nAlvy/M\nAlwin/M\nAlwyn/M\nAlyce/M\nAlyda/M\nAlyosha/M\nAlys/M\nAlysa/M\nAlyse/M\nAlysia/M\nAlyson/M\nAlyss\nAlyssa/M\nAlzheimer/M\nAm/MR\nAmabel/M\nAmabelle/M\nAmadeus/M\nAmado/M\nAmalea/M\nAmalee/M\nAmaleta/M\nAmalia/M\nAmalie/M\nAmalita/M\nAmalle/M\nAmanda/M\nAmandi/M\nAmandie/M\nAmandy/M\nAmara/M\nAmargo/M\nAmarillo/M\nAmata/M\nAmati/M\nAmazon/SM\nAmazonian\nAmber/YM\nAmberly/M\nAmble/M\nAmbros/M\nAmbrose/M\nAmbrosi/M\nAmbrosio/M\nAmbrosius/M\nAmbur/M\nAmby/M\nAmdahl/M\nAme/SM\nAmelia/M\nAmelie/M\nAmelina/M\nAmeline/M\nAmelita/M\nAmenhotep/M\nAmer/M\nAmerada/M\nAmerasian/S\nAmerica/SM\nAmerican/MS\nAmericana/M\nAmericanism/SM\nAmericanization/SM\nAmericanize/SDG\nAmerigo/M\nAmerind/MS\nAmerindian/MS\nAmery/M\nAmeslan/M\nAmharic/M\nAmherst/M\nAmi/M\nAmie/M\nAmiga/M\nAmii/M\nAmil/M\nAmish\nAmitie/M\nAmity/M\nAmmamaria/M\nAmman/M\nAmmerman/M\nAmoco/M\nAmontillado/M\nAmory/M\nAmos\nAmparo/M\nAmpere/M\nAmpex/M\nAmritsar/M\nAmsterdam/M\nAmtrak/M\nAmundsen/M\nAmur/M\nAmway/M\nAmy/M\nAmye/M\nAna/M\nAnabal/M\nAnabaptist/SM\nAnabel/M\nAnabella/M\nAnabelle/M\nAnacin/M\nAnacreon/M\nAnaheim/M\nAnalects/M\nAnaliese/M\nAnalise/M\nAnallese/M\nAnallise/M\nAnanias/M\nAnastasia/M\nAnastasie/M\nAnastassia/M\nAnatol/M\nAnatola/M\nAnatole/M\nAnatolia/M\nAnatolian\nAnatollo/M\nAnaxagoras/M\nAncell/M\nAnchorage/M\nAndalusia/M\nAndalusian\nAndaman\nAndean/M\nAndee/M\nAndeee/M\nAnderea/M\nAnders/N\nAndersen/M\nAnderson/M\nAndes\nAndi/M\nAndie/M\nAndonis/M\nAndorra/M\nAndover/M\nAndra/SM\nAndre/SM\nAndrea/MS\nAndreana/M\nAndree/M\nAndrei/M\nAndrej/M\nAndrew/MS\nAndrey/M\nAndria/M\nAndriana/M\nAndriette/M\nAndris\nAndromache/M\nAndromeda/M\nAndropov/M\nAndros/M\nAndrus/M\nAndy/M\nAnestassia/M\nAnet/M\nAnett/M\nAnetta/M\nAnette/M\nAngara/M\nAnge/M\nAngel/M\nAngela/M\nAngele/SM\nAngeleno/SM\nAngeli/M\nAngelia/M\nAngelica/M\nAngelico/M\nAngelika/M\nAngelina/M\nAngeline/M\nAngelique/M\nAngelita/M\nAngelle/M\nAngelo/M\nAngelou/M\nAngevin/M\nAngie/M\nAngil/M\nAngkor/M\nAngles\nAnglia/M\nAnglican/MS\nAnglicanism/MS\nAnglicism/SM\nAnglicization/MS\nAnglicize/SDG\nAnglo/MS\nAnglophile/SM\nAnglophilia/M\nAnglophobe/MS\nAnglophobia/M\nAngola/M\nAngolan/S\nAngora/MS\nAnguilla/M\nAngus/M\nAngy/M\nAnheuser/M\nAnia/M\nAniakchak/M\nAnibal/M\nAnica/M\nAnissa/M\nAnita/M\nAnitra/M\nAnjanette/M\nAnjela/M\nAnkara/M\nAnn/M\nAnna/M\nAnnabal/M\nAnnabel/M\nAnnabela/M\nAnnabell/M\nAnnabella/M\nAnnabelle/M\nAnnadiana/M\nAnnadiane/M\nAnnalee/M\nAnnaliese/M\nAnnalise/M\nAnnamaria/M\nAnnamarie/M\nAnnapolis/M\nAnnapurna/M\nAnne/M\nAnnecorinne/M\nAnneliese/M\nAnnelise/M\nAnnemarie/M\nAnnetta/M\nAnnette/M\nAnni/MS\nAnnice/M\nAnnie/M\nAnnissa/M\nAnnmaria/M\nAnnmarie/M\nAnnnora/M\nAnnora/M\nAnnunciation/S\nAnny/M\nAnouilh/M\nAnsel/M\nAnsell/M\nAnselm/M\nAnselma/M\nAnselmo/M\nAnshan/M\nAnsley/M\nAnson/M\nAnstice/M\nAntaeus/M\nAntananarivo/M\nAntarctic/M\nAntarctica/M\nAntares\nAnthe/M\nAnthea/M\nAnthia/M\nAnthiathia/M\nAnthony/M\nAntichrist/MS\nAntietam/M\nAntigone/M\nAntigua/M\nAntillean\nAntilles\nAntin/M\nAntioch/M\nAntipas/M\nAntipodes\nAntofagasta/M\nAntoine/M\nAntoinette/M\nAnton/MS\nAntone/M\nAntonella/M\nAntonetta/M\nAntoni/M\nAntonia/M\nAntonie/M\nAntonietta/M\nAntonin/M\nAntonina/M\nAntonino/M\nAntoninus/M\nAntonio/M\nAntonius/M\nAntonovics/M\nAntony/M\nAntwan/M\nAntwerp/M\nAnubis/M\nAny/M\nAnya/M\nApache/MS\nApalachicola/M\nApennines\nAphrodite/M\nApia/M\nApocalypse/M\nApocrypha/M\nApollinaire/M\nApollo/SM\nApollonian\nAppalachia/M\nAppalachian/MS\nAppaloosa/MS\nAppia/M\nAppian/M\nApple/M\nAppleseed/M\nAppleton/M\nAppolonia/M\nAppomattox/M\nApr/M\nApril/MS\nAprilette/M\nApuleius/M\nAquarius/MS\nAquila/M\nAquinas/M\nAquino/M\nAquitaine/M\nAr/MY\nAra/M\nArab/MS\nArabel/M\nArabela/M\nArabele/M\nArabella/M\nArabelle/M\nArabia/M\nArabian/MS\nArabic/M\nArabist/MS\nAraby/M\nAraceli/M\nArafat/M\nAraguaya/M\nAral/M\nAraldo/M\nAramaic/M\nAramco/M\nArapaho/MS\nArapahoe's\nArapahoes\nArarat/M\nAraucanian/M\nArawak/M\nArawakan/M\nArcadia/M\nArcadian\nArch/MR\nArchaimbaud/M\nArchambault/M\nArchean\nArcher/M\nArchibald/M\nArchibaldo/M\nArchibold/M\nArchie/M\nArchimedes/M\nArchy/M\nArctic/M\nArcturus/M\nArda/MH\nArdabil\nArdath/M\nArdeen/M\nArdelia/M\nArdelis/M\nArdella/M\nArdelle/M\nArden/M\nArdene/M\nArdenia/M\nArdine/M\nArdis/M\nArdisj/M\nArdith/M\nArdra/M\nArdyce/M\nArdys\nArdyth/M\nArel/M\nArequipa/M\nAres\nAretha/M\nArgentina/M\nArgentine/SM\nArgentinean/S\nArgentinian/S\nArgo/SM\nArgonaut/MS\nArgonne/M\nArgus/M\nAri/M\nAriadne/M\nAriana/M\nArianism/M\nArianist/SM\nAridatha/M\nArie/SM\nAriel/M\nAriela/M\nAriella/M\nArielle/M\nAries/S\nArin/M\nArio/M\nAriosto/M\nAristarchus/M\nAristides\nAristophanes/M\nAristotelean\nAristotelian/M\nAristotle/M\nArius/M\nAriz/M\nArizona/M\nArizonan/S\nArizonian/S\nArjuna/M\nArk/M\nArkansan/MS\nArkansas/M\nArkhangelsk/M\nArkwright/M\nArlan/M\nArlana/M\nArlee/M\nArleen/M\nArlen/M\nArlena/M\nArlene/M\nArleta/M\nArlette/M\nArley/M\nArleyne/M\nArlie/M\nArliene/M\nArlin/M\nArlina/M\nArlinda/M\nArline/M\nArlington/M\nArluene/M\nArly/M\nArlyn/M\nArlyne/M\nArmada/M\nArmageddon/SM\nArmagnac/M\nArman/M\nArmand/M\nArmando/M\nArmata/M\nArmco/M\nArmenia/M\nArmenian/MS\nArmin/M\nArminius/M\nArmonk/M\nArmour/M\nArmstrong/M\nArnaldo/M\nArne/M\nArneb/M\nArney/M\nArnhem/M\nArni/M\nArnie/M\nArno/M\nArnold/M\nArnoldo/M\nArnuad/M\nArnulfo/M\nArny/M\nAron/M\nArpanet/M\nArragon/M\nArrhenius/M\nArri/M\nArron/M\nArt/M\nArtair/M\nArtaxerxes/M\nArte/M\nArtemas\nArtemis/M\nArtemus/M\nArther/M\nArthur/M\nArthurian\nArtie/M\nArtur/M\nArturo/M\nArtus/M\nArty/M\nAruba/M\nArv/M\nArvie/M\nArvin/M\nArvy/M\nAryan/MS\nAryn/M\nAs\nAsa/M\nAsama/M\nAscella/M\nAscension/M\nAse/M\nAsgard/M\nAsh/MRY\nAshanti/M\nAshbey/M\nAshby/M\nAshely/M\nAsher/M\nAsheville/M\nAshia/M\nAshien/M\nAshil/M\nAshkenazim\nAshkhabad/M\nAshla/M\nAshlan/M\nAshland/M\nAshlee/M\nAshleigh/M\nAshlen/M\nAshley/M\nAshli/M\nAshlie/M\nAshlin/M\nAshly/M\nAshmolean/M\nAshton/M\nAshurbanipal/M\nAsia/M\nAsian/MS\nAsiatic/SM\nAsilomar/M\nAsimov\nAsmara/M\nAsoka/M\nAspell/M\nAspen/M\nAspidiske/M\nAsquith/M\nAssad/M\nAssam/M\nAssamese/M\nAssembly/MS\nAssisi/M\nAssyria/M\nAssyrian/SM\nAssyriology/M\nAstaire/SM\nAstarte/M\nAston/M\nAstor/M\nAstoria/M\nAstra/M\nAstrakhan/M\nAstrid/M\nAstrix/M\nAstroTurf/S\nAstroturf/M\nAsturias/M\nAsuncin/M\nAswan/M\nAt/M\nAtacama/M\nAtahualpa/M\nAtalanta/M\nAtari/M\nAtatrk/M\nAthabasca/M\nAthabascan's\nAthabaska's\nAthabaskan/MS\nAthena/M\nAthene/M\nAthenian/SM\nAthens/M\nAtkins/M\nAtkinson/M\nAtlanta/M\nAtlante/MS\nAtlantic/M\nAtlantis/M\nAtlas/SM\nAtman\nAtreus/M\nAtria/M\nAtropos/M\nAts\nAttic\nAttica/M\nAttila/M\nAttlee/M\nAttn\nAttucks\nAtwood/M\nAu/M\nAube/M\nAuberge/M\nAuberon/M\nAubert/M\nAuberta/M\nAubine/M\nAubree/M\nAubrette/M\nAubrey/M\nAubrie/M\nAubry/M\nAuckland/M\nAuden/M\nAudi/M\nAudie/M\nAudra/M\nAudre/M\nAudrey/M\nAudrie/M\nAudry/M\nAudrye/M\nAudubon/M\nAudy/M\nAuerbach/M\nAug/M\nAugean\nAugie/M\nAugust/SM\nAugusta/M\nAugustan/S\nAuguste/M\nAugustin/M\nAugustina/M\nAugustine/M\nAugustinian/S\nAugusto/M\nAugustus/M\nAugy/M\nAundrea/M\nAura/M\nAurea/M\nAurel/M\nAurelea/M\nAurelia/M\nAurelie/M\nAurelio/M\nAurelius/M\nAureomycin/M\nAuria/M\nAurie/M\nAuriga/M\nAurilia/M\nAurlie/M\nAuroora/M\nAurora/M\nAurore/M\nAurthur/M\nAuschwitz/M\nAussie/MS\nAusten/M\nAustin/SM\nAustina/M\nAustine/M\nAustralasia/M\nAustralasian/S\nAustralia/M\nAustralian/MS\nAustralis/M\nAustraloid\nAustralopithecus/M\nAustria/M\nAustrian/SM\nAustronesian\nAutumn/M\nAva/M\nAvalon/M\nAve/MS\nAveline/M\nAventine/M\nAventino/M\nAverell/M\nAveril/M\nAverill/M\nAvernus/M\nAverroes/M\nAvery/M\nAveryl/M\nAvesta/M\nAvicenna/M\nAvictor/M\nAvie/M\nAvigdor/M\nAvignon/M\nAvila/M\nAvior/M\nAvis\nAviv/M\nAviva/M\nAvivah/M\nAvogadro/M\nAvon/M\nAvram/M\nAvril/M\nAvrit/M\nAvrom/M\nAx/M\nAxe/M\nAxel/M\nAyala/M\nAyers\nAylmar/M\nAylmer/M\nAymara/M\nAymer/M\nAyn/M\nAzania/M\nAzazel/M\nAzerbaijan/M\nAzores\nAzov/M\nAztec/MS\nAztecan\nB's\nB/GT\nBA\nBASIC\nBB\nBBB\nBBC\nBBQ\nBBS\nBC\nBCD\nBIOS\nBITNET/M\nBLT\nBM\nBMW/M\nBO\nBR\nBS\nBSA\nBSD\nBTU\nBTW\nBYOB\nBa/M\nBaal/SM\nBab/SM\nBabar's\nBabara/M\nBabb/M\nBabbage/M\nBabbette/M\nBabbie/M\nBabbitt/M\nBabcock/M\nBabel/MS\nBabette/M\nBabita/M\nBabka/M\nBabylon/MS\nBabylonia/M\nBabylonian/SM\nBacall/M\nBacardi/M\nBacchanalia/M\nBacchic\nBacchus/M\nBach/M\nBackus/M\nBacon/M\nBactria/M\nBaden/M\nBadlands/M\nBaedeker/SM\nBaez/M\nBaffin/M\nBaghdad/M\nBagrodia/MS\nBaguio/M\nBaha'i\nBaha'ullah\nBahama/MS\nBahamanian/S\nBahamian/MS\nBahia/M\nBahrain/M\nBaikal/M\nBail/M\nBailey/SM\nBailie/M\nBaillie/M\nBaily/M\nBaird/M\nBaja/M\nBakelite/M\nBaker/M\nBakersfield/M\nBaku/M\nBakunin/M\nBalanchine/M\nBalboa/M\nBald/MR\nBalder/M\nBalduin/M\nBaldwin/M\nBale/M\nBalearic/M\nBalfour/M\nBali/M\nBalinese\nBalkan/SM\nBalkhash/M\nBall/M\nBallard/SM\nBalthazar/M\nBaltic/M\nBaltimore/M\nBaluchistan/M\nBalzac/M\nBamako/M\nBamberger/M\nBambi/M\nBambie/M\nBamby/M\nBan/M\nBanach/M\nBancroft/M\nBandung/M\nBangalore/M\nBangkok/M\nBangladesh/M\nBangladeshi/S\nBangor/M\nBangui/M\nBanjarmasin/M\nBanjul/M\nBank/MS\nBanky/M\nBanneker/M\nBannister/M\nBanting/M\nBantu/SM\nBaotou/M\nBaptist/MS\nBaptiste/M\nBar/MH\nBarabbas/M\nBarb/RM\nBarbabas/M\nBarbabra/M\nBarbadian/S\nBarbados/M\nBarbara/M\nBarbaraanne/M\nBarbarella/M\nBarbarossa/M\nBarbary/M\nBarbe/M\nBarbee/M\nBarber/M\nBarbette/M\nBarbey/M\nBarbi/M\nBarbie/M\nBarbour/M\nBarbra/M\nBarbuda/M\nBarby/M\nBarcelona/M\nBarclay/M\nBard/M\nBarde/M\nBardeen/M\nBarents/M\nBari/M\nBarker/M\nBarkley/M\nBarlow/M\nBarn/M\nBarnabas\nBarnabe/M\nBarnaby/M\nBarnard/M\nBarnaul/M\nBarnebas/M\nBarnes\nBarnett/M\nBarney/M\nBarnhard/M\nBarnie/M\nBarnum/M\nBarny/M\nBaroda/M\nBaron/M\nBarquisimeto/M\nBarr/M\nBarranquilla/M\nBarrera/M\nBarret/M\nBarrett/M\nBarri/SM\nBarrie/M\nBarron/M\nBarry/M\nBarrymore/MS\nBarstow/M\nBart/M\nBartel/M\nBarth/M\nBarthel/M\nBartholdi/M\nBartholemy/M\nBartholomeo/M\nBartholomeus/M\nBartholomew/M\nBartie/M\nBartlet/M\nBartlett/M\nBartolemo/M\nBartolomeo/M\nBarton/M\nBartram/M\nBarty/M\nBartk/M\nBary/M\nBaryram/M\nBaryshnikov/M\nBascom/M\nBase/M\nBasel/M\nBasho/M\nBasia/M\nBasie/M\nBasil/M\nBasile/M\nBasilio/M\nBasilius/M\nBasque/SM\nBasra/M\nBass/M\nBasseterre/M\nBassett/M\nBastian/M\nBastien/M\nBastille/M\nBasutoland/M\nBat/M\nBataan/M\nBatavia/M\nBates\nBatholomew/M\nBathsheba/M\nBatista/M\nBatman/M\nBatsheva/M\nBattle/M\nBatu/M\nBaudelaire/M\nBaudoin/M\nBaudouin/M\nBauer/M\nBauhaus/M\nBausch/M\nBavaria/M\nBavarian/S\nBax/M\nBaxie/M\nBaxter/M\nBaxy/M\nBay/MR\nBayamon\nBayard/M\nBayda/M\nBayer/M\nBayes\nBayesian\nBaylor/M\nBayonne/M\nBayreuth/M\nBe/MH\nBea/M\nBeach/M\nBeadle/M\nBeale/M\nBealle/M\nBean/M\nBear/M\nBeard/M\nBeardmore/M\nBeardsley/M\nBearnaise/M\nBearnard/M\nBeasley/M\nBeatlemania/M\nBeatles/M\nBeatrice/M\nBeatrisa/M\nBeatrix/M\nBeatriz/M\nBeau/M\nBeauchamps\nBeaufort/M\nBeaujolais/M\nBeaumarchais/M\nBeaumont/M\nBeauregard/M\nBeauvoir/M\nBeaverton/M\nBebe/M\nBecca/M\nBechtel/M\nBeck/RM\nBecka/M\nBecker/M\nBecket/M\nBeckett/M\nBecki/M\nBeckie/M\nBecky/M\nBecquerel/M\nBede/M\nBedford/M\nBedouin/SM\nBee/M\nBeebe/M\nBeecher/M\nBeelzebub/M\nBeerbohm/M\nBeethoven/M\nBeeton/M\nBegin/M\nBehan/M\nBehring/M\nBeiderbecke/M\nBeijing\nBeilul/M\nBeirut/M\nBeitris/M\nBekesy/M\nBekki/M\nBel/M\nBela/M\nBelarus\nBelau/M\nBelem/M\nBelfast/M\nBelg/M\nBelgian/MS\nBelgium/M\nBelgrade/M\nBelia/M\nBelicia/M\nBelinda/M\nBelita/M\nBelize/M\nBell/M\nBella/M\nBellamy/M\nBellanca/M\nBellatrix/M\nBelle/M\nBelleville/M\nBellina/M\nBellini/M\nBellovin/M\nBellow/M\nBellwood/M\nBelmont/M\nBelmopan/M\nBeloit/M\nBelorussia's\nBelorussian/S\nBelshazzar/M\nBelton/M\nBeltran/M\nBeltsville/M\nBelushi/M\nBelva/M\nBelvia/M\nBen/M\nBenacerraf/M\nBenares's\nBender/M\nBendick/M\nBendicty/M\nBendite/M\nBendix/M\nBenedetta/M\nBenedetto/M\nBenedick/M\nBenedict/M\nBenedicta/M\nBenedictine/MS\nBenedicto/M\nBenedikt/M\nBenedikta/M\nBenelux/M\nBenet/M\nBenetta/M\nBenetton/M\nBengal/SM\nBengali/M\nBenghazi/M\nBengt/M\nBeniamino/M\nBenin/M\nBeninese\nBenita/M\nBenito/M\nBenjamen/M\nBenjamin/M\nBenji/M\nBenjie/M\nBenjy/M\nBenn/M\nBennett/M\nBenni/M\nBennie/M\nBennington/M\nBenny/M\nBenoit/M\nBenoite/M\nBenson/M\nBent/M\nBentham/M\nBentlee/M\nBentley/MS\nBenton/M\nBenyamin/M\nBenz/M\nBenzedrine/M\nBeograd's\nBeowulf/M\nBer/MG\nBerber/MS\nBerenice/M\nBeret/M\nBerg/NRM\nBergen/M\nBerger/M\nBergerac/M\nBerget/M\nBerglund/M\nBergman/M\nBergson/M\nBergsten/M\nBergstrom/M\nBering/RM\nBeringer/M\nBerk/YM\nBerke/M\nBerkeley/M\nBerkie/M\nBerkley/M\nBerkly/M\nBerkowitz/M\nBerkshire/SM\nBerky/M\nBerle/M\nBerlin/SZRM\nBerliner/M\nBerlioz/M\nBerlitz/M\nBerman/M\nBermuda/MS\nBermudan/S\nBermudian/S\nBern/M\nBerna/M\nBernadene/M\nBernadette/M\nBernadina/M\nBernadine/M\nBernard/M\nBernardina/M\nBernardine/M\nBernardino/M\nBernardo/M\nBernarr/M\nBernays/M\nBernbach/M\nBerne's\nBernelle/M\nBernese\nBernete/M\nBernetta/M\nBernette/M\nBernhard/M\nBernhardt/M\nBerni/M\nBernice/M\nBernie/M\nBerniece/M\nBernini/M\nBernita/M\nBernoulli/M\nBernstein/M\nBerny/M\nBerra/M\nBerri/M\nBerrie/M\nBerry/M\nBert/M\nBerta/M\nBerte/M\nBertha/M\nBerthe/M\nBerti/M\nBertie/M\nBertillon/M\nBertina/M\nBertine/M\nBerton/M\nBertram/M\nBertrand/M\nBertrando/M\nBerty/M\nBeryl/M\nBeryle/M\nBerzelius/M\nBess\nBessel/M\nBessemer/M\nBessie/M\nBessy/M\nBest/M\nBetelgeuse/M\nBeth/M\nBethanne/M\nBethany/M\nBethe/M\nBethena/M\nBethesda/M\nBethina/M\nBethlehem/M\nBethune\nBetsey/M\nBetsy/M\nBetta/M\nBette/M\nBetteann/M\nBetteanne/M\nBetti/M\nBettie/M\nBettina/M\nBettine/M\nBetty/SM\nBettye/M\nBeulah/M\nBev's\nBevan/M\nBeverie/M\nBeverlee/M\nBeverley/M\nBeverlie/M\nBeverly/M\nBevin/M\nBevon/M\nBevvy/M\nBhopal/M\nBhutan/M\nBhutanese\nBhutto/M\nBi/M\nBialystok/M\nBianca/M\nBianco/M\nBianka/M\nBib/M\nBibbie/M\nBibby/M\nBibbye/M\nBibi/M\nBible/MS\nBiddie/M\nBiddle/M\nBiddy/M\nBidget/M\nBienville/M\nBierce/M\nBigelow/M\nBigfoot\nBiko/M\nBil/MY\nBilbao/M\nBilbo/M\nBili/M\nBill/JM\nBilli/M\nBillie/M\nBillings/M\nBilly/M\nBillye/M\nBimini/M\nBing/M\nBingham/M\nBinghamton/M\nBini/M\nBink/M\nBinky/M\nBinni/M\nBinnie/M\nBinny/M\nBioko/M\nBirch/M\nBird/M\nBirdie/M\nBirdseye/M\nBirgit/M\nBirgitta/M\nBirk/M\nBirkenstock/M\nBirmingham/M\nBiro/M\nBiron/M\nBiscay/M\nBiscayne/M\nBishkek\nBishop/M\nBismarck/M\nBismark/M\nBissau/M\nBizet/M\nBjorn/M\nBk/M\nBlack's\nBlackburn/M\nBlackfeet\nBlackfoot/M\nBlackman/M\nBlackmer/M\nBlackpool/M\nBlackstone/M\nBlackwell/MS\nBlaine/M\nBlair/M\nBlaire/M\nBlake/M\nBlakelee/M\nBlakeley/M\nBlakey/M\nBlanca/M\nBlanch/M\nBlancha/M\nBlanchard/M\nBlanche/M\nBlane/M\nBlankenship/M\nBlanton/M\nBlantyre/M\nBlatz/M\nBlavatsky/M\nBlayne/M\nBleeker/M\nBlenheim/M\nBlevins/M\nBligh/M\nBlinni/M\nBlinnie/M\nBlinny/M\nBliss/M\nBlisse/M\nBlithe/M\nBloch/M\nBloemfontein/M\nBlomberg/M\nBlomquist/M\nBlondell/M\nBlondelle/M\nBlondie/M\nBlondy/M\nBloom/MR\nBloomer/M\nBloomfield/M\nBloomington/M\nBlucher/M\nBluebeard/M\nBlum/M\nBlumenthal/M\nBlvd\nBlythe/M\nBo/MRZ\nBob/M\nBobbe/M\nBobbee/M\nBobbette/M\nBobbi/M\nBobbie/M\nBobbitt/M\nBobbsey/M\nBobby/M\nBobbye/M\nBobette/M\nBobina/M\nBobine/M\nBobinette/M\nBobrow/M\nBoca/M\nBoccaccio/M\nBodenheim/M\nBodhidharma/M\nBodhisattva/M\nBoeing/M\nBoeotia/M\nBoeotian\nBoer/M\nBogart/M\nBogartian/M\nBogey/M\nBogot/M\nBoheme/M\nBohemia/SM\nBohemian/SM\nBohr/M\nBoigie/M\nBois/M\nBoise/M\nBoleyn/M\nBolivar/M\nBolivia/M\nBolivian/S\nBologna/M\nBolshevik/MS\nBolshevism/MS\nBolshevist/MS\nBolshevistic/M\nBolshoi/M\nBolton/M\nBoltzmann/M\nBombay/M\nBonaparte/M\nBonaventure/M\nBond/M\nBondie/M\nBondon/M\nBondy/M\nBone/M\nBonham/M\nBoniface/M\nBonita/M\nBonn/RM\nBonnee/M\nBonner/M\nBonneville/M\nBonni/M\nBonnibelle/M\nBonnie/M\nBonny/M\nBontempo/M\nBooker/M\nBoole/M\nBoolean\nBoone/M\nBoonie/M\nBoony/M\nBoot/M\nBoote/M\nBooth/M\nBoothe/M\nBootle/M\nBord/MN\nBordeaux/M\nBorden/M\nBordie/M\nBordon/M\nBordy/M\nBorealis/M\nBoreas/M\nBorg/M\nBorges\nBorgia/M\nBoris\nBork/M\nBorn/M\nBorneo/M\nBorodin/M\nBorroughs/M\nBoru/M\nBosch/M\nBose/M\nBosnia/M\nBosnian/S\nBosporus/M\nBostitch/M\nBoston/MS\nBostonian/SM\nBoswell/MS\nBotswana/M\nBotticelli/M\nBoucher/M\nBoulder/M\nBourbaki/M\nBourbon/SM\nBourke/M\nBourne/M\nBournemouth/M\nBouvier\nBovary/M\nBowditch/M\nBowell/M\nBowen/M\nBowers\nBowery/M\nBowes\nBowie/M\nBowman/M\nBoy/MR\nBoyce/M\nBoycey/M\nBoycie/M\nBoyd/M\nBoyer/M\nBoyle/M\nBotes\nBr/TMN\nBrad/MYN\nBradan/M\nBradbury/M\nBradburys\nBraddock/M\nBrade/M\nBraden/M\nBradford/M\nBradley/M\nBradly/M\nBradney/M\nBradshaw/M\nBradstreet/M\nBrady/M\nBragg/M\nBrahe/M\nBrahma/MS\nBrahman/SM\nBrahmanism/MS\nBrahmaputra/M\nBrahmin's\nBrahms\nBraille/GDSM\nBrain/M\nBrainard/SM\nBram/M\nBrampton/M\nBran/M\nBrana/M\nBranch/M\nBranchville/M\nBrand/MRN\nBrandais/M\nBrande/M\nBrandea/M\nBrandeis/M\nBrandel/M\nBranden/M\nBrandenburg/M\nBrander/M\nBrandi/M\nBrandice/M\nBrandie/M\nBrandise/M\nBrando/M\nBrandon/M\nBrandt/M\nBrandtr/M\nBrandy/M\nBrandyn/M\nBraniff/M\nBrannon/M\nBrant/M\nBrantley/M\nBraque/M\nBrasilia\nBratislava/M\nBrattain/M\nBraun/M\nBray/M\nBrazil/M\nBrazilian/MS\nBrazos/M\nBrazzaville/M\nBreanne/M\nBrear/M\nBreathalyzer/SM\nBrecht/M\nBreckenridge/M\nBree/M\nBreena/M\nBremen/M\nBren/M\nBrena/M\nBrenda/M\nBrendan/M\nBrenden/M\nBrendin/M\nBrendis/M\nBrendon/M\nBrenn/RNM\nBrenna/M\nBrennan/M\nBrennen/M\nBrenner/M\nBrent/M\nBrenton/M\nBresenham/M\nBrest/M\nBret/M\nBreton\nBrett/M\nBrew/RM\nBrewer/M\nBrewster/M\nBrezhnev/M\nBria/M\nBrian/M\nBriana/M\nBrianna/M\nBrianne/M\nBriano/M\nBriant/M\nBrice/M\nBridalveil/M\nBride/M\nBridewell/M\nBridgeport/M\nBridger/M\nBridges\nBridget/M\nBridgetown/M\nBridgett/M\nBridgette/M\nBridgewater/M\nBridgman/M\nBridie/M\nBrie/RSM\nBrien/M\nBrier/M\nBrietta/M\nBrig/M\nBrigadoon\nBrigg/MS\nBrigham/M\nBright/M\nBrighton/M\nBrigid/M\nBrigida/M\nBrigit/M\nBrigitta/M\nBrigitte/M\nBrillo\nBrillouin/M\nBrina/M\nBrindisi/M\nBriney/M\nBrinkley/M\nBrinn/M\nBrinna/M\nBriny/M\nBrion/M\nBrisbane/M\nBristol/M\nBrit/MS\nBrita/M\nBritain/M\nBritannia/M\nBritannic\nBritannica/M\nBriticism/MS\nBritish/RYZ\nBritisher/M\nBritishly/M\nBritney/M\nBritni/M\nBriton/MS\nBritt/MN\nBritta/M\nBrittan/M\nBrittaney/M\nBrittani/M\nBrittany/MS\nBritte/M\nBritten/M\nBritteny/M\nBrittne/M\nBrittney/M\nBrittni/M\nBrnaba/M\nBrnaby/M\nBrno/M\nBroadway/SM\nBrobdingnag/M\nBrobdingnagian\nBrock/M\nBrockie/M\nBrocky/M\nBrod/M\nBroddie/M\nBroddy/M\nBroderic/M\nBroderick/M\nBrodie/M\nBrody/M\nBroglie/M\nBrok/M\nBron/M\nBronnie/M\nBronny/M\nBronson/M\nBronte\nBronx/M\nBrook/SM\nBrookdale/M\nBrooke/M\nBrookfield/M\nBrookhaven/M\nBrooklyn/M\nBrookmont/M\nBros\nBrose/M\nBrown/MG\nBrowne/M\nBrownell/M\nBrownian/M\nBrownie/MS\nBrowning/M\nBrownsville/M\nBrubeck/M\nBruce/M\nBrucie/M\nBruckner/M\nBruegel/M\nBrueghel's\nBruis/M\nBrumidi/M\nBrummel/M\nBrunei/M\nBrunelleschi/M\nBrunhilda/M\nBrunhilde/M\nBruno/M\nBrunswick/M\nBrussels\nBrutus/M\nBruxelles/M\nBryan/M\nBryana/M\nBryant/M\nBryanty/M\nBryce/M\nBryn/M\nBryna/M\nBrynn/RM\nBrynna/M\nBrynne/M\nBrynner/M\nBryon/M\nBrzezinski/M\nBtu\nBuber/M\nBuchanan/M\nBucharest/M\nBuchenwald/M\nBuchwald/M\nBuck/M\nBuckie/M\nBuckingham/M\nBuckley/M\nBuckner/M\nBucky/M\nBud/M\nBudapest/M\nBudd/M\nBuddha/MS\nBuddhism/SM\nBuddhist/SM\nBuddie/M\nBuddy/M\nBudweiser/MS\nBuehring/M\nBuena/M\nBuffalo/M\nBuffy/M\nBuford/M\nBugatti/M\nBuick/M\nBuiron/M\nBujumbura/M\nBukhara/M\nBukharin/M\nBulawayo/M\nBulba/M\nBulfinch/M\nBulganin/M\nBulgaria/M\nBulgarian/S\nBullock/M\nBullwinkle/M\nBultmann/M\nBumbry/M\nBumppo/M\nBunche/M\nBundestag/M\nBundy/M\nBunin/M\nBunker/M\nBunni/M\nBunnie/M\nBunny/M\nBunsen/SM\nBunyan/M\nBurbank/M\nBurch/M\nBurg/RM\nBurger/M\nBurgess/M\nBurgoyne/M\nBurgundian/S\nBurgundy/MS\nBurk/SM\nBurke/M\nBurl/M\nBurlie/M\nBurlingame/M\nBurlington/M\nBurma/M\nBurmese\nBurnaby/M\nBurnard/M\nBurne/MS\nBurnett/M\nBurns\nBurnside/MS\nBurr/M\nBurris/M\nBurroughs/M\nBursa/M\nBurt/M\nBurtie/M\nBurton/M\nBurty/M\nBurundi/M\nBurundian/S\nBusch/M\nBush/M\nBushido/M\nBushnell/M\nButch/M\nButler/M\nButterfield/M\nBuxtehude/M\nBuuel/M\nByelorussia's\nByers/M\nByram/M\nByran/M\nByrann/M\nByrd/M\nByrle/M\nByrne/M\nByrom/M\nByron/M\nByronic\nByronism/M\nByzantine/S\nByzantium/M\nC\nC's\nCA\nCACM\nCAD\nCAI\nCALCOMP/M\nCAM\nCAP\nCARE\nCATV\nCB\nCBC\nCBS\nCCTV\nCCU\nCD\nCDC/M\nCDT\nCENTREX/M\nCEO\nCERN/M\nCF\nCFC\nCFO\nCIA\nCID\nCMOS\nCNN\nCNS\nCO\nCOBOL\nCOD\nCOL\nCOLA\nCPA\nCPI\nCPO\nCPR\nCPU/SM\nCRT/S\nCST\nCT\nCV\nCZ\nCa/M\nCabernet/M\nCabot/M\nCabrera/M\nCabrini/M\nCacilia/M\nCacilie/M\nCad/M\nCaddric/M\nCadette/S\nCadillac/MS\nCadiz/M\nCaedmon/M\nCaesar/MS\nCage/M\nCagney/M\nCahokia/M\nCahra/M\nCaiaphas/M\nCain/MS\nCaine/M\nCairistiona/M\nCairo/M\nCaitlin/M\nCaitrin/M\nCajun/MS\nCal/MY\nCalComp/M\nCalais/M\nCalcomp/M\nCalcutta/M\nCalder/M\nCalderon/M\nCaldwell/M\nCale/M\nCaleb/M\nCaledonia/M\nCalgary/M\nCalhoun/M\nCali/M\nCaliban/M\nCalida/M\nCalif/M\nCalifornia/M\nCalifornian/MS\nCaligula/M\nCalla/MS\nCallaghan/M\nCallahan/M\nCallao/M\nCallean/M\nCalley/M\nCalli/M\nCallida/M\nCallie/M\nCalliope/M\nCallisto/M\nCally/M\nCaloocan/M\nCaltech/M\nCalumet/M\nCalv/M\nCalvary/M\nCalvert/M\nCalvin/M\nCalvinism/MS\nCalvinist/MS\nCalvinistic\nCalypso/M\nCam/M\nCamacho/M\nCamala/M\nCambodia/M\nCambodian/S\nCambrian/S\nCambridge/M\nCamden/M\nCamel/M\nCamella/M\nCamellia/M\nCamelopardalis/M\nCamelot/M\nCamembert/MS\nCameron/M\nCameroon/SM\nCameroonian/S\nCamey/M\nCami/M\nCamila/M\nCamile/M\nCamilla/M\nCamille/M\nCamino/M\nCammi/M\nCammie/M\nCammy/M\nCamoens/M\nCampbell/M\nCampbellsport/M\nCampinas/M\nCampos\nCamry/M\nCamus/M\nCan/M\nCanaan/M\nCanaanite/SM\nCanad/M\nCanada/M\nCanadian/S\nCanadianism/SM\nCanaletto/M\nCanaries\nCanaveral/M\nCanberra/M\nCancer/MS\nCancun/M\nCandace/M\nCandi/SM\nCandice/M\nCandida/M\nCandide/M\nCandie/M\nCandlewick/M\nCandra/M\nCandy/M\nCanis/M\nCannes\nCannon/M\nCanoga/M\nCanonical\nCanonical's\nCanopus/M\nCantabrigian\nCanterbury/M\nCanton/M\nCantonese/M\nCantor/M\nCantrell/M\nCantu/M\nCanute/M\nCapek/M\nCapella/M\nCapet/M\nCapetown/M\nCaph/M\nCapistrano/M\nCapitan/M\nCapitol/MS\nCapitoline/M\nCapone/M\nCapote/M\nCappy/M\nCapra/M\nCapri/M\nCaprice/M\nCapricorn/MS\nCapt/M\nCapulet/M\nCaputo/M\nCar/MNY\nCara/M\nCaracalla/M\nCaracas/M\nCaralie/M\nCaravaggio/M\nCarboloy/M\nCarbondale/M\nCarbone/MS\nCarboniferous\nCarborundum/MS\nCarce/M\nCardenas/M\nCardiff/M\nCardin/M\nCardiod/M\nCare/M\nCaren/M\nCarena/M\nCaresa/M\nCaressa/M\nCaresse/M\nCarey/M\nCari/M\nCaria/M\nCarib/M\nCaribbean/S\nCarie/M\nCaril/M\nCarilyn/M\nCarin/M\nCarina/M\nCarine/M\nCariotta/M\nCarissa/M\nCarita/M\nCaritta/M\nCarl/MNG\nCarla/M\nCarlee/M\nCarleen/M\nCarlen/M\nCarlene/M\nCarleton/M\nCarletonian/M\nCarley/M\nCarlie/M\nCarlin/M\nCarlina/M\nCarline/M\nCarling/M\nCarlita/M\nCarlo/SM\nCarlota/M\nCarlotta/M\nCarlsbad/M\nCarlson/M\nCarlton/M\nCarly/M\nCarlye/M\nCarlyle/M\nCarlyn/M\nCarlynn/M\nCarlynne/M\nCarma/M\nCarmel/M\nCarmela/M\nCarmelia/M\nCarmelina/M\nCarmelita/M\nCarmella/M\nCarmelle/M\nCarmelo/M\nCarmen/M\nCarmencita/M\nCarmichael/M\nCarmina/M\nCarmine/M\nCarmita/M\nCarmon/M\nCarnap/M\nCarnegie/M\nCarney/M\nCarnot/M\nCarny/M\nCaro/M\nCarol/M\nCarola/M\nCarolan/M\nCarolann/M\nCarole/M\nCarolee/M\nCarolin/M\nCarolina/MS\nCaroline/M\nCarolingian\nCarolinian/S\nCaroljean/M\nCarolus/M\nCarolyn/M\nCarolyne/M\nCarolynn/M\nCaron/M\nCarpathian/MS\nCarpenter/M\nCarr/M\nCarree/M\nCarri/M\nCarrie/M\nCarrier/M\nCarrillo/M\nCarrissa/M\nCarrol/M\nCarroll/M\nCarry/MR\nCarson/M\nCart/MR\nCarter/M\nCartesian\nCarthage/M\nCarthaginian/S\nCartier/M\nCartwright/M\nCarty/RM\nCaruso/M\nCarver/M\nCary/M\nCaryl/M\nCaryn/M\nCasablanca/M\nCasals/M\nCasandra/M\nCasanova/SM\nCasar/M\nCascades/M\nCase/M\nCasey/M\nCash/M\nCasi/M\nCasie/M\nCaspar/M\nCasper/M\nCaspian\nCass\nCassandra/SM\nCassandre/M\nCassandry/M\nCassatt/M\nCassaundra/M\nCassey/M\nCassi/M\nCassie/M\nCassiopeia/M\nCassite/M\nCassius/M\nCassondra/M\nCassy/M\nCastaneda/M\nCastile's\nCastillo/M\nCastor/M\nCastries/M\nCastro/M\nCatalan/MS\nCatalina/M\nCatalonia/M\nCatarina/M\nCatawba/M\nCate/M\nCaterina/M\nCaterpillar\nCatha/M\nCatharina/M\nCatharine/M\nCathay/M\nCathe/RM\nCathee/M\nCather/M\nCatherin/M\nCatherina/M\nCatherine/M\nCathi/M\nCathie/M\nCathleen/M\nCathlene/M\nCatholic/S\nCatholicism/SM\nCathrin/M\nCathrine/M\nCathryn/M\nCathy/M\nCathyleen/M\nCati/M\nCatie/M\nCatiline/M\nCatina/M\nCatlaina/M\nCatlee/M\nCatlin/M\nCato/M\nCatrina/M\nCatriona/M\nCatskill/SM\nCatt/M\nCatullus/M\nCaty/M\nCaucasian/S\nCaucasoid/S\nCaucasus/M\nCauchy/M\nCavendish/M\nCavour/M\nCaxton/M\nCaye/M\nCayenne/M\nCayla/M\nCayman/M\nCayuga/M\nCaz/M\nCazzie/M\nCb/M\nCchaddie/M\nCd/M\nCe\nCeausescu/M\nCebu/M\nCebuano/M\nCece/M\nCecelia/M\nCecil/M\nCecile/M\nCeciley/M\nCecilia/M\nCecilio/M\nCecilius/M\nCecilla/M\nCecily/M\nCed/M\nCedric/M\nCeil/M\nCelanese/M\nCele/M\nCelebes's\nCelene/M\nCelesta/M\nCeleste/M\nCelestia/M\nCelestina/M\nCelestine/M\nCelestyn/M\nCelestyna/M\nCelia/M\nCelie/M\nCelina/M\nCelinda/M\nCeline/M\nCelinka/M\nCelisse/M\nCelka/M\nCelle/M\nCellini/M\nCello/M\nCelsius/S\nCelt/MS\nCeltic/SM\nCenozoic\nCentaurus/M\nCentigrade\nCentralia/M\nCentrex\nCepheid\nCepheus/M\nCerberus/M\nCerenkov/M\nCeres/M\nCerf/M\nCervantes/M\nCesar/M\nCesare/M\nCesarean\nCesaro/M\nCessna/M\nCesya/M\nCetus/M\nCeylon/M\nCeylonese\nCezanne/S\nCf/M\nCh'in\nCh/MGNRS\nChablis/SM\nChad/M\nChadd/M\nChaddie/M\nChaddy/M\nChadian/S\nChadwick/M\nChaffey/M\nChagall/M\nChaim/M\nChaldea/M\nChaldean/M\nChalmers\nChamberlain/M\nChambers/M\nChamplain/M\nChan/M\nChance/M\nChancellorsville/M\nChancey/M\nChanda/M\nChandal/M\nChandigarh/M\nChandler/M\nChandra/M\nChandragupta/M\nChandrasekhar/M\nChandy/M\nChane/M\nChanel/M\nChaney/M\nChang/M\nChangchun/M\nChangsha/M\nChanna/M\nChanning/M\nChantal/M\nChantalle/M\nChantilly/M\nChanukah's\nChao/M\nChaplin/M\nChapman/M\nChappaquiddick/M\nChara\nChardonnay\nCharil/M\nCharin/M\nChariot/M\nCharis\nCharissa/M\nCharisse/M\nCharita/M\nCharity/M\nCharla/M\nCharlean/M\nCharleen/M\nCharlemagne/M\nCharlena/M\nCharlene/M\nCharles/M\nCharleston/SM\nCharley/M\nCharlie/M\nCharline/M\nCharlot/M\nCharlotta/M\nCharlotte/M\nCharlottesville/M\nCharlottetown/M\nCharlton/M\nCharmain/M\nCharmaine/M\nCharmane/M\nCharmian/M\nCharmin/M\nCharmine/M\nCharmion/M\nCharo/M\nCharolais\nCharon/M\nChartres/M\nCharybdis/M\nCharyl/M\nChas\nChase/M\nChasity/M\nChastity/M\nChateaubriand\nChattahoochee/M\nChattanooga/M\nChatterley/M\nChatterton/M\nChaucer/M\nChaunce/M\nChauncey/M\nChautauqua/M\nChavez/M\nChayefsky/M\nChe/M\nChechen/M\nChechnya/M\nCheddar/MS\nCheerios/M\nCheeto/M\nCheever/M\nChekhov/M\nChelsae/M\nChelsea/M\nChelsey/M\nChelsie/M\nChelsy/M\nChelyabinsk/M\nChen/M\nCheng/M\nChengdu\nCheops/M\nCher/M\nChere/M\nCherey/M\nCheri/M\nCherianne/M\nCherice/M\nCherida/M\nCherie/M\nCherilyn/M\nCherilynn/M\nCherin/M\nCherise/M\nCherish/M\nCheriton/M\nCherlyn/M\nChernenko/M\nChernobyl/M\nCherokee/MS\nCherri/M\nCherrita/M\nCherry/M\nChery/M\nCherye/M\nCheryl/M\nChesapeake/M\nCheshire/M\nCheslie/M\nChester/M\nChesterfield/M\nChesterton/M\nCheston/M\nChet/M\nChev/M\nChevalier/M\nCheviot/M\nChevrolet/M\nChevy/M\nCheyenne/SM\nChi/M\nChiang/M\nChianti/S\nChiarra/M\nChiba/M\nChic/M\nChicago/M\nChicagoan/SM\nChicana/MS\nChicano/MS\nChick/M\nChickasaw/SM\nChickie/M\nChicky/M\nChico/M\nChihuahua/MS\nChile/MS\nChilean/S\nChilton/M\nChimborazo/M\nChimera/S\nChimiques\nChimu/M\nChin/M\nChina/M\nChinaman/M\nChinamen\nChinatown/SM\nChinese/M\nChing/M\nChinook/MS\nChip/M\nChipewyan/M\nChippendale/M\nChippewa/MS\nChiquia/M\nChiquita/M\nChirico/M\nChisholm/M\nChisinau/M\nChittagong/M\nChlo/M\nChloe/M\nChloette/M\nChloris\nChoctaw/MS\nChomsky/M\nChongqing\nChopin/M\nChou/M\nChretien/M\nChris/M\nChrisse/M\nChrissie/M\nChrissy/M\nChrist/SMN\nChrista/M\nChristabel/M\nChristabella/M\nChristal/M\nChristalle/M\nChristan/M\nChristchurch/M\nChristean/M\nChristel/M\nChristen/M\nChristendom/MS\nChristensen/M\nChristenson/M\nChristi/M\nChristian/MS\nChristiana/M\nChristiane/M\nChristianity/SM\nChristianize/GSD\nChristiano/M\nChristians/N\nChristiansen/M\nChristie/SM\nChristin/M\nChristina/M\nChristine/M\nChristlike\nChristmas/SM\nChristmastide/SM\nChristmastime/S\nChristoffel/M\nChristoffer/M\nChristoforo/M\nChristoper/M\nChristoph/MR\nChristophe/M\nChristopher/M\nChristophorus/M\nChristos/M\nChristy's\nChristye/M\nChristyna/M\nChrisy/M\nChrotoem/M\nChrysa/M\nChrysler/M\nChrysostom/M\nChrystal/M\nChryste/M\nChrystel/M\nChucho/M\nChuck/M\nChukchi/M\nChumash/M\nChung/M\nChungking's\nChurch/MS\nChurchill/M\nChurchillian\nChuvash/M\nCi\nCicely/M\nCicero/M\nCiceronian\nCicily/M\nCid/M\nCiel/M\nCilka/M\nCincinnati/M\nCinda/M\nCindee/M\nCindelyn/M\nCinderella/MS\nCindi/M\nCindie/M\nCindra/M\nCindy/M\nCinerama/M\nCinnamon/M\nCirce/M\nCirillo/M\nCirilo/M\nCiro/M\nCissiee/M\nCissy/M\nCitibank/M\nCitroen/M\nCl/VM\nClaiborn/M\nClaiborne/M\nClair/M\nClaire/M\nClairol/M\nClancy/M\nClapeyron/M\nClapton/M\nClara/M\nClarabelle/M\nClarance/M\nClare/M\nClaremont/M\nClarence/M\nClarendon/M\nClaresta/M\nClareta/M\nClaretta/M\nClarette/M\nClarey/M\nClari/M\nClaribel/M\nClarice/M\nClarie/M\nClarinda/M\nClarine/M\nClarissa/M\nClarisse/M\nClarita/M\nClark/M\nClarke/M\nClarridge/M\nClary/M\nClaude/M\nClaudell/M\nClaudelle/M\nClaudetta/M\nClaudette/M\nClaudia/M\nClaudian/M\nClaudianus/M\nClaudie/M\nClaudina/M\nClaudine/M\nClaudio/M\nClaudius/M\nClaus/NM\nClausen/M\nClausewitz/M\nClausius/M\nClay/M\nClayborn/M\nClayborne/M\nClaybourne/M\nClayson/M\nClayton/M\nClea/M\nClearwater/M\nCleavland/M\nClem/XM\nClemence/M\nClemenceau/M\nClement/MS\nClemente/M\nClementia/M\nClementina/M\nClementine/M\nClementius/M\nClemmie/M\nClemmy/M\nClemons\nClemson/M\nCleo/M\nCleon/M\nCleopatra/M\nClerc/M\nClerissa/M\nCletis\nCletus/M\nCleve/M\nCleveland/M\nClevey/M\nClevie/M\nCliburn/M\nCliff/M\nClifford/M\nClifton/M\nClim/M\nCline/M\nClint/M\nClinton/M\nClio/M\nClive/M\nClo/M\nCloe/M\nCloris/M\nClotho/M\nClotilda/M\nClovis/M\nCluj/M\nCly/M\nClyde/M\nClydesdale/M\nClytemnestra/M\nClyve/M\nClywd/M\nCm/M\nCo/M\nCoates/M\nCob/M\nCobain/M\nCobb/M\nCobbie/M\nCobby/M\nCobol/M\nCochabamba/M\nCochin/M\nCochise/M\nCochran/M\nCockney\nCocteau/M\nCod/M\nCodee/M\nCodi/M\nCodie/M\nCody/M\nCoffey/M\nCoffman/M\nCognac/M\nCohan/M\nCohen/M\nCohn/M\nCoimbatore/M\nCointon/M\nCoke/MS\nCol/MY\nColan/M\nColas\nColbert/M\nColby/M\nCole/M\nColeen/M\nColeman/M\nColene/M\nColeridge/M\nColet/M\nColetta/M\nColette/M\nColfax/M\nColgate/M\nColin/M\nColleen/M\nCollen/M\nCollete/M\nCollette/M\nCollie/M\nCollier/M\nCollin/MS\nColline/M\nColly/RM\nColman/M\nColo/M\nCologne/M\nColombia/M\nColombian/S\nColombo/M\nColon/M\nColoradan/S\nColorado/M\nColoradoan/S\nColosseum/M\nColt/M\nColtrane/M\nColumbia/M\nColumbian\nColumbine/M\nColumbus/M\nColver/M\nCom/M\nComanche/MS\nCombs/M\nComdex/M\nComdr/M\nCominform/M\nCommie\nCommons/M\nCommonwealth/M\nCommonwealths\nCommunion/SM\nCommunism/S\nCommunist/S\nComoros\nCompaq/M\nCompton/M\nCompuServe/M\nCompuserve/M\nComte/M\nCon/M\nConakry/M\nConan/M\nConant/M\nConcepcin/M\nConcetta/M\nConcettina/M\nConchita/M\nConcord/MS\nConcorde/M\nConcordia/M\nCondorcet/M\nConestoga\nConfederacy/M\nConfederate/S\nConfucian/S\nConfucianism/SM\nConfucius/M\nCong/M\nCongo/M\nCongolese\nCongregational\nCongregationalist/S\nCongress/MS\nCongreve/M\nConley/M\nConn/RM\nConnecticut/M\nConnelly/M\nConner/M\nConnery/M\nConney/M\nConni/M\nConnie/M\nConnor/SM\nConny/M\nConrad/M\nConrade/M\nConrado/M\nConrail/M\nConroy/M\nConsalve/M\nConservative/S\nConsolata/M\nConstable/M\nConstance/M\nConstancia/M\nConstancy/M\nConstanta/M\nConstantia/M\nConstantin/M\nConstantina/M\nConstantine/M\nConstantino/M\nConstantinople/M\nConstitution\nConsuela/M\nConsuelo/M\nContinent/M\nContinental/S\nContreras/M\nConway/M\nCook/M\nCooke/M\nCookie/M\nCooley/M\nCoolidge/M\nCoop/MR\nCooper/M\nCoors/M\nCopeland/M\nCopenhagen/M\nCopernican\nCopernicus/M\nCopland/M\nCopley/M\nCopperfield/M\nCoppola/M\nCoptic/M\nCora/M\nCorabel/M\nCorabella/M\nCorabelle/M\nCoral/M\nCoralie/M\nCoraline/M\nCoralyn/M\nCorbet/M\nCorbett/M\nCorbie/M\nCorbin/M\nCorby/M\nCord/M\nCordelia/M\nCordelie/M\nCordell/M\nCordey/M\nCordi/M\nCordie/M\nCordilleras\nCordoba\nCordula/M\nCordy/M\nCoreen/M\nCorella/M\nCorenda/M\nCorene/M\nCoretta/M\nCorette/M\nCorey/M\nCorfu/M\nCori/M\nCorie/M\nCorilla/M\nCorina/M\nCorine/M\nCorinna/M\nCorinne/M\nCorinth/M\nCorinthian/S\nCorinthians/M\nCoriolanus/M\nCoriolis/M\nCoriss/M\nCorissa/M\nCork/M\nCorliss/M\nCorly/M\nCormack/M\nCornall/M\nCorneille/M\nCornela/M\nCornelia/M\nCornelius/M\nCornell/M\nCornelle/M\nCorney/M\nCornie/M\nCornish/S\nCornwall/M\nCornwallis/M\nCorny/M\nCoronado/M\nCorot/M\nCorp\nCorreggio/M\nCorrena/M\nCorrey/M\nCorri/M\nCorrianne/M\nCorrie/M\nCorrina/M\nCorrine/M\nCorrinne/M\nCorry/M\nCorsica/M\nCorsican/S\nCort/M\nCortes/S\nCortez's\nCortie/M\nCortland/M\nCortney/M\nCorty/M\nCorvallis/M\nCorvus/M\nCory/M\nCos\nCosby/M\nCosetta/M\nCosette/M\nCosimo/M\nCosme/M\nCosmo/M\nCossack/SM\nCosta/M\nCostanza/M\nCostello/M\nCostner/M\nCote/M\nCotonou/M\nCotopaxi/M\nCotton/M\nCoulomb/M\nCouperin/M\nCourbet/M\nCourt/M\nCourtenay/M\nCourtnay/M\nCourtney/M\nCousteau/M\nCovent/M\nCoventry/MS\nCoward/M\nCowley/M\nCowper/M\nCox/M\nCoy/M\nCozmo/M\nCozumel/M\nCpl\nCr/M\nCrabbe/M\nCraft/M\nCraggie/M\nCraggy/M\nCraig/M\nCramer/M\nCranach/M\nCrandall/M\nCrane/M\nCranford/M\nCranmer/M\nCranston/M\nCrater/M\nCrawford/M\nCray/SM\nCrayola/M\nCreation/M\nCreator/M\nCree/MDS\nCreek/SM\nCreigh/M\nCreight/M\nCreighton/M\nCreole/MS\nCreon/M\nCrestview/M\nCretaceous/Y\nCretaceously/M\nCretan/S\nCrete/M\nCrichton/M\nCrick/M\nCrimea/M\nCrimean\nCrin/M\nCris/M\nCrisco/M\nCrissie/M\nCrissy/M\nCrista/M\nCristabel/M\nCristal/M\nCristen/M\nCristi/M\nCristian/M\nCristiano/M\nCristie/M\nCristin/M\nCristina/M\nCristine/M\nCristionna/M\nCristobal/M\nCristy/M\nCroat/SM\nCroatia/M\nCroatian/S\nCroce/M\nCrockett/M\nCrockpot/M\nCroesus/SM\nCroix/M\nCromwell/M\nCromwellian\nCronin/M\nCronkite/M\nCronus/M\nCrookes/M\nCrosby/M\nCross/M\nCrowley/M\nCrucifixion/MS\nCruikshank/M\nCrusoe/M\nCrux/M\nCruz/M\nCryptozoic/M\nCrysta/M\nCrystal/M\nCrystie/M\nCs\nCt/M\nCthrine/M\nCu/M\nCuba/M\nCuban/S\nCuchulain/M\nCuisinart/M\nCulbertson/M\nCull/MN\nCullan/M\nCullen/M\nCulley/M\nCullie/M\nCullin/M\nCully/M\nCulver/MS\nCumberland/M\nCummings\nCunard/M\nCunningham/M\nCupertino/M\nCupid/M\nCuracao/M\nCurcio/M\nCurie/M\nCuritiba/M\nCurr/M\nCurran/M\nCurrey/M\nCurrie/M\nCurrier/M\nCurry/MR\nCurt/M\nCurtice/M\nCurtis/M\nCushman/M\nCuster/M\nCuvier/M\nCuzco/M\nCy/M\nCyanamid/M\nCyb/M\nCybele/M\nCybil/M\nCybill/M\nCyclades\nCyclopes\nCyclops/M\nCygnus/M\nCymbre/M\nCynde/M\nCyndi/M\nCyndia/M\nCyndie/M\nCyndy/M\nCynthea/M\nCynthia/M\nCynthie/M\nCynthy/M\nCyprian\nCypriot/SM\nCyprus/M\nCyrano/M\nCyril/M\nCyrill/M\nCyrille/M\nCyrillic\nCyrillus/M\nCyrus/M\nCzech\nCzechoslovak/S\nCzechoslovakia/M\nCzechoslovakian/S\nCzechs\nCzerniak/M\nCzerny/M\nD\nD'Arcy\nD's\nDA\nDAG\nDARPA/M\nDAT\nDB\nDBMS\nDC\nDD\nDDS\nDDT\nDE\nDEC/M\nDECNET\nDECnet/M\nDECstation/M\nDECsystem/M\nDECtape/M\nDH\nDI\nDJ\nDMD\nDMZ\nDNA\nDOA\nDOB\nDOD\nDOE\nDOS\nDOT\nDP\nDPT\nDPs\nDST\nDTP\nDUI\nDWI\nDacca's\nDacey/M\nDachau/M\nDacia/M\nDacie/M\nDacron/MS\nDacy/M\nDada/M\nDadaism/M\nDadaist/M\nDade/M\nDaedalus/M\nDael/M\nDaffi/M\nDaffie/M\nDaffy/M\nDag/M\nDagmar/M\nDagny/M\nDaguerre/M\nDagwood/M\nDahl/M\nDahlia/M\nDahomey/M\nDaile/M\nDaimler/M\nDaisey/M\nDaisi/M\nDaisie/M\nDaisy/M\nDakar/M\nDakota/SM\nDakotan\nDal/M\nDale/M\nDalenna/M\nDaley/M\nDalhousie/M\nDali/SM\nDalia/M\nDalian/M\nDalila/M\nDall/M\nDallas/M\nDalli/MS\nDallon/M\nDalmatia/M\nDalmatian/SM\nDaloris/M\nDalston/M\nDalt/M\nDalton/M\nDaly/M\nDamara/M\nDamaris/M\nDamascus/M\nDame/SMN\nDamian/M\nDamiano/M\nDamien/M\nDamion/M\nDamita/M\nDamocles/M\nDamon/M\nDan/SM\nDana/M\nDana\nDanbury/M\nDane/SM\nDanelaw/M\nDanell/M\nDanella/M\nDanette/M\nDangerfield/M\nDani/M\nDania/M\nDanial/M\nDanica/M\nDanice/M\nDanie/M\nDaniel/SM\nDaniela/M\nDaniele/M\nDaniella/M\nDanielle/M\nDanielson/M\nDanika/M\nDanila/M\nDanish\nDanit/M\nDanita/M\nDanna/M\nDannel/M\nDanni/M\nDannie/M\nDanny/M\nDannye/M\nDante/M\nDanton/M\nDanube/M\nDanubian\nDanville/M\nDanya/M\nDanyelle/M\nDanyette/M\nDanzig/M\nDaphene/M\nDaphna/M\nDaphne/M\nDar/MNH\nDara/M\nDarb/M\nDarbee/M\nDarbie/M\nDarby/M\nDarcee/M\nDarcey/M\nDarci/M\nDarcie/M\nDarcy/M\nDarda/M\nDardanelles\nDare/M\nDareen/M\nDarell/M\nDarelle/M\nDaren/M\nDari/M\nDaria/M\nDarice/M\nDarill/M\nDarin/M\nDario/M\nDarius/M\nDarjeeling/M\nDarla/M\nDarleen/M\nDarlene/M\nDarline/M\nDarling/M\nDarlington/M\nDarlleen/M\nDarn/M\nDarnall/M\nDarnell/M\nDaron/M\nDarrel/M\nDarrell/M\nDarrelle/M\nDarren/M\nDarrick/M\nDarrin/M\nDarrow/M\nDarryl/M\nDarsey/M\nDarsie/M\nDarth/M\nDartmouth/M\nDarvon/M\nDarwin/M\nDarwinian/S\nDarwinism/MS\nDarwinist/MS\nDarya/M\nDaryl/M\nDaryle/M\nDaryn/M\nDasha/M\nDasi/M\nDasie/M\nDasya/M\nDatamation/M\nDatamedia/M\nDatha/M\nDatsun/M\nDaugherty/M\nDaumier/M\nDaune/M\nDav/MN\nDavao/M\nDave/M\nDaveen/M\nDaven/M\nDavenport/M\nDaveta/M\nDavey/M\nDavid/SM\nDavida/M\nDavidde/M\nDavide/M\nDavidson/M\nDavie/M\nDavin/M\nDavina/M\nDavine/M\nDavinich/M\nDavis/M\nDavita/M\nDavon/M\nDavy/SM\nDawes/M\nDawn/M\nDawna/M\nDawson/M\nDay/M\nDayle/M\nDayna/M\nDayton/M\nDdene/M\nDe/NM\nDeKalb/M\nDeKastere/M\nDeMorgan/M\nDean/M\nDeana/M\nDeandre/M\nDeane/M\nDeann/M\nDeanna/M\nDeanne/M\nDearborn/M\nDeb/MS\nDebbi/M\nDebbie/M\nDebby/M\nDebee/M\nDebera/M\nDebi/M\nDebian\nDebian's\nDebor/M\nDebora/M\nDeborah/M\nDebra/M\nDebussy/M\nDec/M\nDecalogue/M\nDecatur/M\nDecca/M\nDeccan/M\nDecember/SM\nDeck/RM\nDecker/M\nDede/M\nDedekind/M\nDedie/M\nDedra/M\nDee/M\nDeeann/M\nDeeanne/M\nDeedee/M\nDeena/M\nDeerdre/M\nDeere/M\nDeeyn/M\nDefoe/M\nDegas/M\nDehlia/M\nDeidre/M\nDeimos/M\nDeina/M\nDeirdre/MS\nDeity/M\nDejesus/M\nDel/MY\nDela/M\nDelacroix/M\nDelacruz/M\nDelainey/M\nDelaney/M\nDelano/M\nDelaware/MS\nDelawarean/SM\nDelbert/M\nDelcina/M\nDelcine/M\nDeleon/M\nDelft/M\nDelgado/M\nDelhi/M\nDelia/M\nDelibes/M\nDelila/M\nDelilah/M\nDelilahs\nDelinda/M\nDelius/M\nDell/M\nDella/M\nDellwood/M\nDelly/M\nDelmar/M\nDelmarva/M\nDelmer/M\nDelmonico\nDelmor/M\nDelmore/M\nDelora/M\nDelores/M\nDeloria/M\nDeloris/M\nDelphi/M\nDelphic\nDelphine/M\nDelphinia/M\nDelphinus/M\nDelta/M\nDem/MG\nDemavend/M\nDemerol/M\nDemeter/M\nDemetra/M\nDemetre/M\nDemetri/MS\nDemetria/M\nDemetrius/M\nDeming/M\nDemocrat/MS\nDemocratic\nDemocritus/M\nDemosthenes/M\nDemott/M\nDempsey/M\nDen/M\nDena/M\nDene/M\nDeneb/M\nDenebola/M\nDeneen/M\nDeng/M\nDeni/SM\nDenice/M\nDenise/M\nDenmark/M\nDenna/M\nDennet/M\nDenney/M\nDenni/MS\nDennie/M\nDennison/M\nDenny/M\nDenver/M\nDeny/M\nDenys\nDenyse/M\nDeon/M\nDeonne/M\nDependant/MS\nDept/M\nDer/M\nDerby/SM\nDerbyshire/M\nDerek/M\nDerick/M\nDerk/M\nDermot/M\nDerrek/M\nDerrick/M\nDerrida/M\nDerrik/M\nDerril/M\nDerron/M\nDerry/M\nDerward/M\nDerwin/M\nDes\nDescartes/M\nDesdemona/M\nDesi/M\nDesirae/M\nDesiree/M\nDesiri/M\nDesmond/M\nDesmund/M\nDetroit/M\nDeuteronomy/M\nDeutsch/M\nDev/M\nDeva/M\nDevan/M\nDevanagari/M\nDevi/M\nDevin/M\nDevina/M\nDevinne/M\nDevland/M\nDevlen/M\nDevlin/M\nDevon/M\nDevondra/M\nDevonian\nDevonna/M\nDevonne/M\nDevonshire/M\nDevora/M\nDevy/M\nDew/M\nDewain/M\nDewar/M\nDewayne/M\nDewey/M\nDewie/M\nDewitt/M\nDex/M\nDexedrine/M\nDexter/M\nDhaka\nDhaulagiri/M\nDi/M\nDiCaprio/M\nDiMaggio/M\nDiaghilev/M\nDiahann/M\nDian/M\nDiana/M\nDiandra/M\nDiane/M\nDianemarie/M\nDiann/M\nDianna/M\nDianne/M\nDiannne/M\nDiarmid/M\nDiaspora/SM\nDiaz's\nDick/XM\nDickens/M\nDickensian/S\nDickerson/M\nDickie/M\nDickinson/M\nDickson/M\nDicky/M\nDictaphone/SM\nDiderot/M\nDidi/M\nDido/M\nDiefenbaker/M\nDiego/M\nDiem/M\nDiena/M\nDierdre/M\nDiesel's\nDieter/M\nDietrich/M\nDietz/M\nDijkstra/M\nDijon/M\nDilan/M\nDilbert/M\nDill/M\nDillard/M\nDillie/M\nDillinger/M\nDillon/M\nDilly/M\nDimitri/M\nDimitry/M\nDina/M\nDinah/M\nDinnie/M\nDinny/M\nDino/M\nDiocletian/M\nDiogenes/M\nDion/M\nDione/M\nDionis/M\nDionisio/M\nDionne/M\nDionysian\nDionysus/M\nDiophantine/M\nDior/M\nDipper/M\nDir\nDirac/M\nDirichlet/M\nDirk/M\nDis\nDisney/M\nDisneyland/M\nDisraeli/M\nDita/M\nDitzel/M\nDix/M\nDixie/M\nDixiecrat/MS\nDixieland/MS\nDixon/M\nDjakarta's\nDjibouti/M\nDmitri/M\nDnepr's\nDnepropetrovsk/M\nDnieper's\nDniester/M\nDniren/M\nDobbin/M\nDoberman\nDobro/M\nDoctor\nDoctorow/M\nDode/M\nDodge/M\nDodgson/M\nDodi/M\nDodie/M\nDodington/M\nDodoma/M\nDodson/M\nDody/M\nDoe/M\nDoge/M\nDogtown/M\nDoha/M\nDolby/SM\nDole/M\nDolf/M\nDoll/M\nDolley/M\nDolli/M\nDollie/M\nDolly/M\nDolores/M\nDolorita/SM\nDolph/M\nDom/M\nDomenic/M\nDomenico/M\nDomeniga/M\nDomesday/M\nDominga/M\nDomingo/M\nDominguez/M\nDomini/M\nDominic/M\nDominica/M\nDominican/MS\nDominick/M\nDominik/M\nDominique/M\nDomitian/M\nDon/SM\nDona/M\nDonahue/M\nDonal/M\nDonald/M\nDonaldson/M\nDonall/M\nDonalt/M\nDonatello/M\nDonaugh/M\nDonavon/M\nDonella/M\nDonelle/M\nDonetsk/M\nDonetta/M\nDonia/M\nDonica/M\nDonielle/M\nDonizetti/M\nDonn/RM\nDonna/M\nDonnamarie/M\nDonne/M\nDonnell/M\nDonnelly/M\nDonner/M\nDonni/M\nDonnie/M\nDonny/M\nDonovan/M\nDooley/M\nDoolittle/M\nDoonesbury/M\nDoppler/M\nDora/M\nDorado/M\nDoralia/M\nDoralin/M\nDoralyn/M\nDoralynn/M\nDoralynne/M\nDorcas\nDorchester/M\nDoreen/M\nDorelia/M\nDorella/M\nDorelle/M\nDorena/M\nDorene/M\nDoretta/M\nDorette/M\nDorey/M\nDori/MS\nDoria/M\nDorian/M\nDoric\nDorice/M\nDorie/M\nDorine/M\nDorisa/M\nDorise/M\nDorita/M\nDoro/M\nDorolice/M\nDorolisa/M\nDorotea/M\nDoroteya/M\nDorothea/M\nDorothee/M\nDorothy/M\nDorree/M\nDorri/SM\nDorrie/M\nDorry/M\nDorsey/M\nDorthea/M\nDorthy/M\nDortmund/M\nDory/M\nDor/M\nDosi/M\nDostoevsky/M\nDot/M\nDoti/M\nDotson/M\nDotti/M\nDottie/M\nDotty/M\nDouala/M\nDouay/M\nDoubleday/M\nDoug/M\nDougherty/M\nDougie/M\nDouglas/M\nDouglass\nDougy/M\nDouro/M\nDov/MR\nDover/M\nDow/M\nDowney/M\nDowns\nDoy/M\nDoyle/M\nDr/M\nDraco/M\nDraconian\nDracula/M\nDrake/M\nDramamine/MS\nDrambuie/M\nDrano/M\nDravidian/M\nDre/M\nDreddy/M\nDredi/M\nDreiser/M\nDresden/M\nDrew/M\nDrexel/M\nDreyfus/M\nDreyfuss\nDrona/M\nDru/M\nDruci/M\nDrucie/M\nDrucill/M\nDrucy/M\nDrud/M\nDrugi/M\nDruid's\nDrummond/M\nDrury/M\nDrusi/M\nDrusie/M\nDrusilla/M\nDrusy/M\nDryden/M\nDshubba/M\nDu/M\nDuPont/MS\nDuane/M\nDubai/M\nDubcek/M\nDubhe/M\nDublin/M\nDubrovnik/M\nDubuque/M\nDuchamp/M\nDud/M\nDudley/M\nDuff/M\nDuffie/M\nDuffy/M\nDugald/M\nDuisburg/M\nDuke/M\nDukey/M\nDukie/M\nDuky/M\nDulce/M\nDulcea/M\nDulci/M\nDulcia/M\nDulciana/M\nDulcie/M\nDulcine/M\nDulcinea/M\nDulcy/M\nDulles/M\nDulsea/M\nDuluth/M\nDumas\nDumbo/M\nDumont/M\nDumpster/S\nDumpty/M\nDun/M\nDunant/M\nDunbar/M\nDunc/M\nDuncan/M\nDundee/M\nDunedin/M\nDunham/M\nDunkirk/M\nDunlap/M\nDunn/M\nDunne/M\nDunstan/M\nDupont/MS\nDur/M\nDuracell/M\nDuran/M\nDurand/M\nDurant/M\nDurante/M\nDurban/M\nDurex/M\nDurham/MS\nDurkee/M\nDurkheim/M\nDurocher/M\nDurward/M\nDuse/M\nDusenberg/M\nDusenbury/M\nDushanbe/M\nDustin/M\nDusty/M\nDutch/M\nDutchman/M\nDutchmen\nDutchwoman\nDutchwomen\nDuvalier/M\nDvina/M\nDvork/M\nDwain/M\nDwayne/M\nDwight/M\nDy/M\nDyan/M\nDyana/M\nDyane/M\nDyann/M\nDyanna/M\nDyanne/M\nDyer/M\nDyke/M\nDylan/M\nDyna/M\nDynah/M\nDzerzhinsky/M\nDrer/M\nDsseldorf\nE\nE's\nEBCDIC\nEC\nECG\nEDP\nEDT\nEEC\nEEG\nEEO\nEEOC\nEFL\nEFT\nEGA/M\nEKG\nEM\nEMT\nENE\nEOE\nEPA\nER\nERA\nESE\nESL\nESP\nEST\nET\nETA\nETD\nEU\nEachelle/M\nEada/M\nEadie/M\nEadith/M\nEadmund/M\nEakins/M\nEal/M\nEalasaid/M\nEamon/M\nEarhart/M\nEarl/M\nEarle/M\nEarlene/M\nEarlie/M\nEarline/M\nEarly/M\nEarnest/M\nEarnestine/M\nEarp/M\nEartha/M\nEarvin/M\nEast/ZSMR\nEaster/M\nEastern/RZ\nEasterner/M\nEasthampton/M\nEastland/M\nEastman/M\nEastwick/M\nEastwood/M\nEaton/M\nEb/MN\nEba/M\nEbba/M\nEben/M\nEbeneezer/M\nEbeneser/M\nEbenezer/M\nEberhard/M\nEberto/M\nEbola\nEbonee/M\nEbonics\nEbony/M\nEbro/M\nEccles\nEcclesiastes/M\nEco/M\nEcole/M\nEconometrica/M\nEcstasy/S\nEcuador/M\nEcuadoran/S\nEcuadorean/S\nEcuadorian/S\nEd/XMN\nEda/M\nEdam/SM\nEdan/M\nEdd/M\nEdda/M\nEddi/M\nEddie/M\nEddy/M\nEde/M\nEdee/M\nEdeline/M\nEden/M\nEdgar/M\nEdgard/M\nEdgardo/M\nEdgerton/M\nEdgewater/M\nEdgewood/M\nEdi/MH\nEdie/M\nEdik/M\nEdin/M\nEdinburgh/M\nEdison/M\nEdita/M\nEdith/M\nEditha/M\nEdithe/M\nEdiva/M\nEdlin/M\nEdmon/M\nEdmond/M\nEdmonton/M\nEdmund/M\nEdna/M\nEdouard/M\nEdsel/M\nEdsger/M\nEduard/M\nEduardo/M\nEdubuntu\nEdubuntu's\nEduino/M\nEdvard/M\nEdward/SM\nEdwardian\nEdwardo/M\nEdwin/M\nEdwina/M\nEdy/M\nEdyth/M\nEdythe/M\nEeyore/M\nEffie/M\nEfrain/M\nEfrem/M\nEfren/M\nEgan/M\nEgbert/M\nEgerton/M\nEgon/M\nEgor/M\nEgypt/M\nEgyptian/S\nEgyptology/M\nEhrlich/M\nEichmann/M\nEiffel/M\nEileen/M\nEilis/M\nEimile/M\nEinstein/SM\nEinsteinian\nEire/M\nEirena/M\nEisenhower/M\nEisenstein/M\nEisner/M\nEkaterina/M\nEkberg/M\nEkstrom/M\nEktachrome/M\nEl/MY\nElaina/M\nElaine/M\nElana/M\nElane/M\nElanor/M\nElayne/M\nElba/MS\nElbe/M\nElbert/M\nElberta/M\nElbertina/M\nElbertine/M\nElbrus/M\nElden/M\nEldin/M\nEldon/M\nEldorado's\nEldredge/M\nEldridge/M\nEleanor/M\nEleanora/M\nEleanore/M\nEleazar/M\nElectra/M\nEleen/M\nElena/M\nElene/M\nEleni/M\nElenore/M\nEleonora/M\nEleonore/M\nElfie/M\nElfreda/M\nElfrida/M\nElfrieda/M\nElga/M\nElgar/M\nEli/M\nElia/SM\nElianora/M\nElianore/M\nElicia/M\nElie/M\nElihu/M\nElijah/M\nElinor/M\nElinore/M\nEliot/M\nElisa/M\nElisabet/M\nElisabeth/M\nElisabetta/M\nElise/M\nEliseo/M\nElisha/M\nElissa/M\nElita/M\nEliza/M\nElizabet/M\nElizabeth/M\nElizabethan/S\nElka/M\nElke/M\nElkhart/M\nElla/M\nElladine/M\nEllary/M\nElle/M\nEllen/M\nEllene/M\nEllerey/M\nEllery/M\nEllesmere/M\nEllette/M\nElli/SM\nEllie/M\nEllington/M\nElliot/M\nElliott/M\nEllison/M\nEllissa/M\nEllswerth/M\nEllsworth/M\nEllwood/M\nElly/M\nEllyn/M\nEllynn/M\nElma/M\nElmer/M\nElmhurst/M\nElmira/M\nElmo/M\nElmore/M\nElmsford/M\nElna/MH\nElnar/M\nElnath/M\nElnora/M\nElnore/M\nElohim/M\nEloisa/M\nEloise/M\nElonore/M\nElora/M\nEloy/M\nElroy/M\nElsa/M\nElsbeth/M\nElse/M\nElset/M\nElsey/M\nElsi/M\nElsie/M\nElsinore/M\nElspeth/M\nElston/M\nElsworth/M\nElsy/M\nEltanin/M\nElton/M\nElva/M\nElvera/M\nElvia/M\nElvin/M\nElvina/M\nElvira/M\nElvis/M\nElvyn/M\nElwin/M\nElwira/M\nElwood/M\nElwyn/M\nEly/M\nElyn/M\nElyse/M\nElysees\nElysha/M\nElysia/M\nElysian\nElysium/SM\nElyssa/M\nElyse/M\nEm/M\nEma/M\nEmacs/M\nEmalee/M\nEmalia/M\nEmanuel/M\nEmanuele/M\nEmelda/M\nEmelen/M\nEmelia/M\nEmelina/M\nEmeline/M\nEmelita/M\nEmelyne/M\nEmera/M\nEmerson/M\nEmery/M\nEmil/M\nEmile/M\nEmilee/M\nEmili/M\nEmilia/M\nEmilie/M\nEmiline/M\nEmilio/M\nEmily/M\nEminence/MS\nEmlen/M\nEmlyn/M\nEmlynn/M\nEmlynne/M\nEmma/M\nEmmalee/M\nEmmaline/M\nEmmalyn/M\nEmmalynn/M\nEmmalynne/M\nEmmanuel/M\nEmmeline/M\nEmmerich/M\nEmmery/M\nEmmet/M\nEmmett/M\nEmmey/M\nEmmi/M\nEmmie/M\nEmmit/M\nEmmott/M\nEmmy/SM\nEmmye/M\nEmogene/M\nEmory/M\nEmyle/M\nEmylee/M\nEndicott/M\nEndymion/M\nEng/M\nEngel/MS\nEngelbert/M\nEngland/M\nEnglebert/M\nEnglewood/M\nEnglish/GDRSM\nEnglishman/M\nEnglishmen\nEnglishwoman/M\nEnglishwomen\nEngracia/M\nEnid/M\nEnif/M\nEniwetok/M\nEnkidu/M\nEnnis/M\nEnoch/M\nEnos\nEnrica/M\nEnrichetta/M\nEnrico/M\nEnrika/M\nEnrique/M\nEnriqueta/M\nEnsolite/M\nEnterprise/M\nEocene\nEolanda/M\nEolande/M\nEphesian/S\nEphesians/M\nEphesus/M\nEphraim/M\nEphrayim/M\nEphrem/M\nEpictetus/M\nEpicurean\nEpicurus/M\nEpimethius/M\nEpiphany/SM\nEpiscopal/S\nEpiscopalian/S\nEpistle/SM\nEpsom/M\nEpstein/M\nEquuleus/M\nEr/M\nEran/M\nErasmus/M\nErastus/M\nErato/M\nEratosthenes/M\nErda/M\nErebus/M\nErek/M\nErena/M\nErhard/M\nErhart/M\nEric/M\nErica/M\nErich/M\nEricha/M\nErick/M\nEricka/M\nErickson/M\nEricson's\nEricsson's\nEridanus/M\nErie/SM\nErik/M\nErika/M\nErikson/M\nErin/M\nErina/M\nErinn/M\nErinna/M\nEris\nEritrea/M\nErl/M\nErlang/M\nErlenmeyer/M\nErma/M\nErmanno/M\nErmengarde/M\nErmentrude/M\nErmin/M\nErmina/M\nErminia/M\nErminie/M\nErna/M\nErnaline/M\nErnest/M\nErnesta/M\nErnestine/M\nErnesto/M\nErnestus/M\nErnie/M\nErnst/M\nErny/M\nEros/SM\nErrick/M\nErrol/M\nErroll/M\nErse/M\nErskine/M\nErtha/M\nErv/M\nErvIn/M\nErvin/M\nErwin/M\nEryn/M\nEs\nEsau/M\nEscher/M\nEscherichia/M\nEscondido/M\nEsdras/M\nEskimo/SM\nEsma/M\nEsmaria/M\nEsmark/M\nEsme/M\nEsmeralda/M\nEsp/M\nEspagnol/M\nEsperanto/M\nEsperanza/M\nEspinoza/M\nEsposito/M\nEsq/M\nEsquire/S\nEsra/M\nEssa/M\nEssen/M\nEssene/SM\nEssequibo/M\nEssex/M\nEssie/M\nEssy/M\nEsta/M\nEstablishment/MS\nEsteban/M\nEstel/M\nEstela/M\nEstele/M\nEstell/M\nEstella/M\nEstelle/M\nEster/M\nEsterhzy/M\nEstes\nEstevan/M\nEsther/M\nEstonia/M\nEstonian/S\nEstrada/M\nEstrella/M\nEstrellita/M\nEtan/M\nEthan/M\nEthe/M\nEthel/M\nEthelbert/M\nEthelda/M\nEthelin/M\nEthelind/M\nEtheline/M\nEthelred/M\nEthelyn/M\nEthernet/MS\nEthiopia/M\nEthiopian/S\nEthyl/M\nEtienne/M\nEtna/M\nEtruria/M\nEtruscan/MS\nEtta/M\nEtti/M\nEttie/M\nEttore/M\nEtty/M\nEu/M\nEucharist/SM\nEucharistic\nEuclid/M\nEudora/M\nEuell/M\nEugen/M\nEugene/M\nEugenia/M\nEugenie/M\nEugenio/M\nEugenius/M\nEugine/M\nEula/M\nEulalie/M\nEuler/M\nEulerian/M\nEumenides\nEunice/M\nEuphemia/M\nEuphrates/M\nEur/M\nEurasia/M\nEurasian/S\nEuripides/M\nEurodollar/SM\nEuropa/M\nEurope/M\nEuropean/MS\nEuropeanization/SM\nEuropeanized\nEurydice/M\nEustace/M\nEustachian/M\nEustacia/M\nEuterpe/M\nEv/MN\nEva/M\nEvaleen/M\nEvan/MS\nEvangelia/M\nEvangelical/S\nEvangelin/M\nEvangelina/M\nEvangeline/M\nEvangelist/MS\nEvania/M\nEvanne/M\nEvanston/M\nEvansville/M\nEve/M\nEveleen/M\nEvelin/M\nEvelina/M\nEveline/M\nEvelyn/M\nEven/M\nEvenki/M\nEverReady/M\nEverard/M\nEveready/M\nEvered/M\nEverest/M\nEverett/M\nEverette/M\nEverglades\nEverhart/M\nEvey/M\nEvie/M\nEvin/M\nEvita/M\nEvonne/M\nEvvie/M\nEvvy/M\nEvy/M\nEvyn/M\nEwan/M\nEward/M\nEwart/M\nEwell/M\nEwen/M\nEwing/M\nExcalibur/M\nExcedrin/M\nExcellency/MS\nExchequer/SM\nExeter/M\nExodus/M\nExxon/M\nEyck/M\nEyde/M\nEydie/M\nEyre/M\nEysenck/M\nEzechiel/M\nEzekiel/M\nEzequiel/M\nEziechiele/M\nEzmeralda/M\nEzra/M\nEzri/M\nF\nF's\nFAA\nFAQ/SM\nFBI\nFCC\nFD\nFDA\nFDIC\nFDR/M\nFHA\nFICA\nFIFO\nFL\nFM\nFNMA/M\nFOFL\nFORTH/M\nFORTRAN\nFPO\nFSLIC\nFTC\nFTP\nFUD\nFWD\nFY\nFYI\nFabe/MR\nFaber/M\nFaberg/M\nFabian/S\nFabiano/M\nFabien/M\nFabio/M\nFae/M\nFaeroe/M\nFafnir/M\nFagin/M\nFahd/M\nFahrenheit/S\nFaina/M\nFair/M\nFairbanks\nFairchild/M\nFairfax/M\nFairfield/M\nFairleigh/M\nFairlie/M\nFairmont/M\nFairport/M\nFairview/M\nFaisal/M\nFaisalabad\nFaith/M\nFalito/M\nFalk/M\nFalkland/MS\nFalkner/M\nFallon/M\nFallopian/M\nFalstaff/M\nFalwell/M\nFan/M\nFanchette/M\nFanchon/M\nFancie/M\nFancy/M\nFanechka/M\nFania/M\nFanni/M\nFannie/M\nFanny/SM\nFanya/M\nFar/MY\nFara/M\nFaraday/M\nFarah/M\nFarand/M\nFarber/M\nFargo/M\nFarica/M\nFarkas/M\nFarlay/M\nFarlee/M\nFarleigh/M\nFarley/M\nFarlie/M\nFarly/M\nFarmer/M\nFarmington/M\nFarr/M\nFarra/M\nFarragut/M\nFarrah/M\nFarrakhan/M\nFarrand/M\nFarrel/M\nFarrell/M\nFarris/M\nFascism's\nFascist's\nFassbinder/M\nFates\nFather/SM\nFatima/M\nFaulkner/M\nFaulknerian\nFaun/M\nFaunie/M\nFauntleroy/M\nFaust/M\nFaustian\nFaustina/M\nFaustine/M\nFaustino/M\nFaustus/M\nFawkes/M\nFawn/M\nFawne/M\nFawnia/M\nFax/M\nFay/M\nFaydra/M\nFaye/M\nFayette/M\nFayetteville/M\nFayina/M\nFayre/M\nFayth/M\nFaythe/M\nFe/M\nFeatherman/M\nFeb/M\nFebruary/MS\nFed/SM\nFedEx/M\nFederal/S\nFederalist\nFederica/M\nFederico/M\nFedora/M\nFee/M\nFelder/M\nFeldman/M\nFelecia/M\nFelic/M\nFelicdad/M\nFelice/M\nFelicia/M\nFelicio/M\nFelicity/M\nFelicle/M\nFelike/M\nFeliks/M\nFelipa/M\nFelipe/M\nFelisha/M\nFelita/M\nFelix/M\nFeliza/M\nFelizio/M\nFellini/M\nFenelia/M\nFenian/M\nFenwick/M\nFeodor/M\nFeodora/M\nFerber/M\nFerd/M\nFerdie/M\nFerdinand/M\nFerdinanda/M\nFerdinande/M\nFerdinando/M\nFerdy/M\nFergus/M\nFerguson/M\nFerlinghetti/M\nFermat/M\nFermi/M\nFern/M\nFernanda/M\nFernande/M\nFernandez/M\nFernandina/M\nFernando/M\nFerne/M\nFerrari/M\nFerraro/M\nFerreira/M\nFerrel/M\nFerrell/M\nFerrer/M\nFerris\nFess/M\nFey/M\nFeynman/M\nFez/M\nFiann/M\nFianna/M\nFiat/M\nFiberglas/M\nFibonacci/M\nFichte/M\nFidel/M\nFidela/M\nFidelia/M\nFidelio/M\nFidelity/M\nFido/M\nFidole/M\nField/MGS\nFielding/M\nFifi/M\nFifine/M\nFigaro/M\nFigueroa/M\nFiji/M\nFijian/SM\nFilbert/M\nFilberte/M\nFilberto/M\nFilia/M\nFilide/M\nFilip/M\nFilipino/SM\nFilippa/M\nFilippo/M\nFillmore/M\nFilmer/M\nFilmore/M\nFilofax/S\nFin/M\nFina/M\nFinch/M\nFindlay/M\nFindley/M\nFinland/M\nFinlay/M\nFinley/M\nFinn/MS\nFinnbogadottir/M\nFinnegan/M\nFinnish\nFiona/M\nFionna/M\nFionnula/M\nFiorello/M\nFiorenze/M\nFiori/M\nFirefox/M\nFirestone/M\nFischbein/M\nFischer/M\nFisher/M\nFishkill/M\nFisk/M\nFiske/M\nFitch/M\nFitchburg/M\nFitz/M\nFitzgerald/M\nFitzpatrick/M\nFitzroy/M\nFizeau/M\nFla/M\nFlanagan/M\nFlanders/M\nFlatt/M\nFlaubert/M\nFledermaus/M\nFleischer/M\nFleischman/M\nFleisher/M\nFlem/JGM\nFleming/M\nFlemish/GDSM\nFlemished/M\nFlemishing/M\nFlemming/M\nFletch/MR\nFletcher/M\nFleur/M\nFleurette/M\nFlin/M\nFlinn/M\nFlint/M\nFlintstones\nFlo/M\nFlor/M\nFlora/M\nFlorance/M\nFlore/SM\nFlorella/M\nFlorence/M\nFlorencia/M\nFlorentia/M\nFlorentine/S\nFlorenza/M\nFlorette/M\nFlori/SM\nFloria/M\nFlorian/M\nFlorida/M\nFloridan/S\nFloridian/S\nFlorie/M\nFlorina/M\nFlorinda/M\nFlorine/M\nFlorri/M\nFlorrie/M\nFlorry/M\nFlory/M\nFlossi/M\nFlossie/M\nFlossy/M\nFlowers\nFloyd/M\nFlss/M\nFlynn/M\nFm/M\nFoch/M\nFokker/M\nFoley/M\nFolsom\nFomalhaut/M\nFonda/M\nFons\nFonsie/M\nFontaine/M\nFontainebleau/M\nFontana/M\nFonz/M\nFonzie/M\nFoote/M\nForbes/M\nFord/M\nFordham/M\nForeman/M\nForest/MR\nForester/M\nFormica/MS\nFormosa/M\nFormosan\nForrest/RM\nForrester/M\nForster/M\nFortaleza/M\nFortran/M\nFoss/M\nFoster/M\nFoucault/M\nFourier/M\nFourth\nFourths\nFowler/M\nFox/MS\nFoxhall/M\nFr/MD\nFragonard/M\nFran/MS\nFrancaise/M\nFrance/MS\nFrancene/M\nFrancesca/M\nFrancesco/M\nFranchot/M\nFrancie/M\nFrancine/M\nFrancis\nFrancisca/M\nFranciscan/MS\nFrancisco/M\nFranciska/M\nFranciskus/M\nFranck/M\nFrancklin/M\nFrancklyn/M\nFranco/M\nFrancois/M\nFrancoise/M\nFrancyne/M\nFrank/SM\nFrankel/M\nFrankenstein/MS\nFrankford/M\nFrankfort/M\nFrankfurt/RM\nFrankfurter/M\nFrankie/M\nFrankish/M\nFranklin/M\nFranklyn/M\nFranky/M\nFranni/M\nFrannie/M\nFranny/M\nFransisco/M\nFrants/M\nFranz/NM\nFranzen/M\nFrasco/M\nFraser/M\nFrasier/M\nFrasquito/M\nFrau/MN\nFraulein/S\nFrayda/M\nFrayne/M\nFraze/MR\nFrazer/M\nFrazier/M\nFred/M\nFreda/M\nFreddi/M\nFreddie/M\nFreddy/M\nFredek/M\nFredelia/M\nFrederic/M\nFrederica/M\nFrederich/M\nFrederick/MS\nFredericka/M\nFrederico/M\nFredericton/M\nFrederigo/M\nFrederik/M\nFrederique/M\nFredholm/M\nFredi/M\nFredia/M\nFredra/M\nFredric/M\nFredrick/M\nFredrickson/M\nFredrika/M\nFree/M\nFreedman/M\nFreeland/M\nFreeman/M\nFreemason/SM\nFreemasonry/MS\nFreemon/M\nFreeport/M\nFreetown/M\nFreida/M\nFremont/M\nFrench/MDSG\nFrenchman/M\nFrenchmen\nFrenchwoman/M\nFrenchwomen\nFreon/SM\nFresnel/M\nFresno/M\nFreud/M\nFreudian/S\nFrey/M\nFreya/M\nFri/M\nFrick/M\nFriday/SM\nFrieda/M\nFriedan/M\nFriederike/M\nFriedman/M\nFriedrich/M\nFriedrick/M\nFrigga/M\nFrigidaire/M\nFrisbee/MS\nFrisco/M\nFrisian/SM\nFrito/M\nFritz/M\nFrobisher/M\nFroissart/M\nFromm/M\nFrontenac/M\nFrost/M\nFrostbelt/M\nFruehauf/M\nFrunze/M\nFry/M\nFrye/M\nFuchs/M\nFuentes/M\nFugger/M\nFuji/M\nFujitsu/M\nFujiyama\nFukuoka/M\nFulani/M\nFulbright/M\nFuller/M\nFullerton/M\nFulton/M\nFulvia/M\nFunafuti\nFundy/M\nFushun/M\nFuzhou/M\nFuzzbuster/M\nG's\nG/B\nGA\nGAO\nGB\nGDP\nGE/M\nGED\nGHQ\nGHz\nGI\nGIGO\nGM\nGMT\nGNOME/M\nGNP\nGOP\nGOTO/MS\nGP\nGPA\nGPO\nGPSS\nGSA\nGU\nGUI\nGa/M\nGabbey/M\nGabbi/M\nGabbie/M\nGabby/M\nGabe/M\nGabey/M\nGabi/M\nGabie/M\nGable/M\nGabon/M\nGabonese\nGaborone/M\nGabriel/M\nGabriela/M\nGabriele/M\nGabriell/M\nGabriella/M\nGabrielle/M\nGabriellia/M\nGabriello/M\nGabrila/M\nGaby/M\nGacrux/M\nGadsden/M\nGae/M\nGaea/M\nGael/SM\nGaelan/M\nGaelic/M\nGagarin/M\nGage/M\nGail/M\nGaile/M\nGaines/M\nGainesville/M\nGainsborough/M\nGaithersburg/M\nGal/MN\nGalahad/MS\nGalapagos/M\nGalatea/M\nGalatia/M\nGalatians/M\nGalaxy/M\nGalbraith/M\nGalbreath/M\nGale/M\nGalen/M\nGalibi/M\nGalilean/MS\nGalilee/M\nGalileo/M\nGalina/M\nGall/M\nGallagher/M\nGallard/M\nGallegos/M\nGallic\nGallicism/SM\nGalloway/M\nGallup/M\nGalois/M\nGalsworthy/M\nGalvan/M\nGalvani/M\nGalven/M\nGalveston/M\nGalvin/M\nGama/M\nGamaliel/M\nGambia/M\nGambian/S\nGamble/M\nGamow/M\nGan/M\nGandhi/M\nGandhian\nGanges/M\nGangtok/M\nGannie/M\nGannon/M\nGanny/M\nGantry/M\nGanymede/M\nGar/MH\nGarald/M\nGarbo/M\nGarcia/M\nGard/M\nGardener/M\nGardie/M\nGardiner/M\nGardner/M\nGardy/M\nGare/MH\nGarek/M\nGareth/M\nGarey/M\nGarfield/M\nGarfunkel/M\nGargantua/M\nGaribaldi/M\nGarik/M\nGarland/M\nGarner/M\nGarnet/M\nGarnett/M\nGarnette/M\nGarold/M\nGarrard/M\nGarrek/M\nGarret/M\nGarreth/M\nGarrett/M\nGarrick/M\nGarrik/M\nGarrison/M\nGarrot/M\nGarrott/M\nGarry/M\nGarth/M\nGarv/M\nGarvey/M\nGarvin/M\nGarvy/M\nGarwin/M\nGarwood/M\nGary/M\nGarza/M\nGascony/M\nGaspar/M\nGaspard/M\nGasparo/M\nGasper/M\nGasser/M\nGasset/M\nGaston/M\nGates\nGatlinburg/M\nGatling/M\nGatorade/M\nGatsby/M\nGatun/M\nGauguin/M\nGaul/MS\nGaulish/M\nGaulle/M\nGaultiero/M\nGauntley/M\nGauss/M\nGaussian\nGautama/M\nGauthier/M\nGautier/M\nGav/MN\nGavan/M\nGaven/M\nGavin/M\nGavra/M\nGavrielle/M\nGawain/M\nGawen/M\nGay/M\nGaye/M\nGayel/M\nGayelord/M\nGayla/M\nGayle/RM\nGayleen/M\nGaylene/M\nGayler/M\nGaylor/M\nGaylord/M\nGaynor/M\nGaza/M\nGaziantep/M\nGd/M\nGdansk/M\nGe/M\nGearalt/M\nGearard/M\nGeary/M\nGehenna/M\nGehrig/M\nGeiger/M\nGeigy/M\nGelya/M\nGemini/SM\nGemma/M\nGen/M\nGena/M\nGenaro/M\nGene/M\nGenesco/M\nGenesis/M\nGenet/M\nGeneva/M\nGenevieve/M\nGenevra/M\nGenghis/M\nGenia/M\nGenna/M\nGenni/M\nGennie/M\nGennifer/M\nGenny/M\nGeno/M\nGenoa/SM\nGenovera/M\nGentile's\nGentry/M\nGenvieve/M\nGeo/M\nGeoff/M\nGeoffrey/M\nGeoffry/M\nGeoras/M\nGeordie/M\nGeorg/M\nGeorge/SM\nGeorgeanna/M\nGeorgeanne/M\nGeorgena/M\nGeorgeta/M\nGeorgetown/M\nGeorgetta/M\nGeorgette/M\nGeorgi/M\nGeorgia/M\nGeorgian/S\nGeorgiana/M\nGeorgianna/M\nGeorgianne/M\nGeorgie/M\nGeorgina/M\nGeorgine/M\nGeorgy/M\nGer/M\nGerald/M\nGeralda/M\nGeraldine/M\nGerard/M\nGerardo/M\nGerber/M\nGerda/M\nGerek/M\nGerhard/M\nGerhardine/M\nGerhardt/M\nGeri/M\nGerianna/M\nGerianne/M\nGerick/M\nGerik/M\nGeritol/M\nGerladina/M\nGermain/M\nGermaine/M\nGerman/SM\nGermana/M\nGermania/M\nGermanic/M\nGermantown/M\nGermany/M\nGermayne/M\nGerome/M\nGeronimo/M\nGerrard/M\nGerri/M\nGerrie/M\nGerrilee/M\nGerry/M\nGershwin/MS\nGert/M\nGerta/M\nGerti/M\nGertie/M\nGertrud/M\nGertruda/M\nGertrude/M\nGertrudis/M\nGerty/M\nGery/M\nGestapo/SM\nGethsemane/M\nGetty/M\nGettysburg/M\nGewrztraminer\nGhana/M\nGhanaian/MS\nGhanian's\nGhats/M\nGhent/M\nGherardo/M\nGhibelline/M\nGiacinta/M\nGiacobo/M\nGiacometti/M\nGiacomo/M\nGiacopo/M\nGian/M\nGiana/M\nGianina/M\nGianna/M\nGianni/M\nGiannini/M\nGiauque/M\nGiavani/M\nGib/M\nGibb/MS\nGibbie/M\nGibbon/M\nGibby/M\nGibraltar/MS\nGibson/M\nGiddings/M\nGide/M\nGideon/MS\nGielgud/M\nGienah/M\nGiff/RM\nGiffard/M\nGiffer/M\nGiffie/M\nGifford/M\nGiffy/M\nGigi/M\nGil/MY\nGila/M\nGilbert/M\nGilberta/M\nGilberte/M\nGilbertina/M\nGilbertine/M\nGilberto/M\nGilbertson/M\nGilburt/M\nGilchrist/M\nGilda/M\nGilead/M\nGilemette/M\nGiles\nGilgamesh/M\nGilkson/M\nGill/M\nGillan/M\nGilles\nGillespie/M\nGillette/M\nGilli/M\nGilliam/M\nGillian/M\nGillie/M\nGilligan/M\nGilly/M\nGilmore/M\nGimbel/M\nGina/M\nGinelle/M\nGinevra/M\nGinger/M\nGingrich/M\nGinni/M\nGinnie/M\nGinnifer/M\nGinny/M\nGino/M\nGinsberg/M\nGinsburg/M\nGioconda/M\nGiordano/M\nGiorgi/M\nGiorgia/M\nGiorgio/M\nGiorgione/M\nGiotto/M\nGiovanna/M\nGiovanni/M\nGipsy's\nGiralda/M\nGiraldo/M\nGiraud/M\nGiraudoux/M\nGisela/M\nGiselbert/M\nGisele/M\nGisella/M\nGiselle/M\nGish/M\nGiuditta/M\nGiulia/M\nGiuliano/M\nGiulietta/M\nGiulio/M\nGiuseppe/M\nGiustina/M\nGiustino/M\nGiusto/M\nGiza/M\nGizela/M\nGk/M\nGlad/M\nGladi/M\nGladstone/MS\nGladys\nGlaser/M\nGlasgow/M\nGlass/M\nGlastonbury/M\nGlaswegian/S\nGleason/M\nGleda/M\nGlen/M\nGlenda/M\nGlendale/M\nGlenden/M\nGlendon/M\nGlenine/M\nGlenn/M\nGlenna/M\nGlennie/M\nGlennis/M\nGlori/M\nGloria/M\nGloriana/M\nGloriane/M\nGlory/M\nGloucester/M\nGlover/M\nGlyn/M\nGlynda/M\nGlynis/M\nGlynn/M\nGlynnis/M\nGnni/M\nGnostic/M\nGnosticism/M\nGoa/M\nGobi/M\nGod/M\nGodard/M\nGodart/M\nGoddard/M\nGoddart/M\nGodfree/M\nGodfrey/M\nGodfry/M\nGodiva/M\nGodot/M\nGodspeed/S\nGodthaab/M\nGodunov/M\nGodwin/M\nGodzilla/M\nGoebbels/M\nGoering/M\nGoethals/M\nGoethe/M\nGoff/M\nGog/M\nGogh/M\nGogol/M\nGoiania/M\nGolan/M\nGolconda/M\nGolda/M\nGoldarina/M\nGoldberg/M\nGolden/M\nGoldi/M\nGoldia/M\nGoldie/M\nGoldilocks/M\nGoldina/M\nGolding/M\nGoldman/M\nGoldsmith/M\nGoldstein/M\nGoldwater/M\nGoldwyn/M\nGoldy/M\nGoleta/M\nGolgotha/M\nGoliath/M\nGoliaths\nGomez/M\nGomorrah/M\nGompers/M\nGondwanaland/M\nGonzales/M\nGonzalez/M\nGonzalo/M\nGoober/M\nGood/M\nGoodman/M\nGoodrich/M\nGoodwin/M\nGoodyear/M\nGoogle/M\nGopher\nGoran/M\nGoraud/M\nGorbachev\nGordan/M\nGorden/M\nGordian/M\nGordie/M\nGordimer/M\nGordon/M\nGordy/M\nGore/M\nGoren/M\nGorey/M\nGorgas\nGorgon/M\nGorgonzola/M\nGorham/M\nGorky/M\nGospel/SM\nGoth/M\nGotham/M\nGothart/M\nGothic/S\nGothicism/M\nGoths\nGottfried/M\nGoucher/M\nGouda/SM\nGould/M\nGounod/M\nGovernor\nGoya/M\nGr/M\nGracchus/M\nGrace/M\nGraceland/M\nGracia/M\nGracie/M\nGraciela/M\nGradeigh/M\nGradey/M\nGrady/M\nGraehme/M\nGraeme/M\nGraff/M\nGraffias/M\nGrafton/M\nGraham/M\nGrahame/M\nGraig/M\nGrail/SM\nGram/M\nGrammy/S\nGrampians\nGran/M\nGranada/M\nGrange/MR\nGranger/M\nGrannie/M\nGranny/M\nGrant/M\nGrantham/M\nGranthem/M\nGrantley/M\nGranville/M\nGrass/M\nGrata/M\nGratia/M\nGratiana/M\nGraves/M\nGray/M\nGrayce/M\nGrayson/M\nGrazia/M\nGrecian/S\nGreece/M\nGreek/SM\nGreeley/M\nGreen/M\nGreenberg/M\nGreenblatt/M\nGreenbriar/M\nGreene/M\nGreenfeld/M\nGreenfield/M\nGreenland/M\nGreenpeace/M\nGreensboro/M\nGreensleeves/M\nGreensville/M\nGreentree/M\nGreenville/M\nGreenwich/M\nGreer/M\nGreg/M\nGregg/M\nGreggory/M\nGregoire/M\nGregoor/M\nGregor/M\nGregorian\nGregorio/M\nGregorius/M\nGregory/M\nGrenada/M\nGrenadian/S\nGrenadines\nGrendel/M\nGrenier/M\nGrenoble/M\nGrenville/M\nGresham/M\nGreta/M\nGretal/M\nGretchen/M\nGrete/M\nGretel/M\nGrethel/M\nGretna/M\nGretta/M\nGretzky/M\nGrey/M\nGrieg/M\nGrier/M\nGriff/M\nGriffie/M\nGriffin/M\nGriffith/M\nGriffy/M\nGrimaldi/M\nGrimes\nGrimm/M\nGrinch/M\nGris/M\nGriselda/M\nGrissel/M\nGriswold/M\nGriz/M\nGromyko/M\nGroot/M\nGropius/M\nGross\nGrosset/M\nGrossman/M\nGrosvenor/M\nGrosz/M\nGrotius/M\nGroton/M\nGrove/RM\nGrover/M\nGrumman/M\nGrundy/M\nGrus/M\nGrusky/M\nGruyeres\nGruyre\nGrnewald/M\nGuadalajara/M\nGuadalcanal/M\nGuadalquivir/M\nGuadalupe/M\nGuadeloupe/M\nGuallatiri/M\nGualterio/M\nGuam/M\nGuamanian/SM\nGuangzhou\nGuantanamo/M\nGuarani/M\nGuardia/M\nGuarnieri/M\nGuatemala/M\nGuatemalan/S\nGuayaquil/M\nGucci/M\nGuelph/M\nGuendolen/M\nGuenevere/M\nGuenna/M\nGuenther/M\nGuernsey/SM\nGuerra/M\nGuerrero/M\nGuevara/M\nGuggenheim/M\nGuglielma/M\nGuglielmo/M\nGuhleman/M\nGui/M\nGuiana/M\nGuido/M\nGuilbert/M\nGuillaume/M\nGuillema/M\nGuillemette/M\nGuillermo/M\nGuinea/M\nGuinean/S\nGuinevere/M\nGuinna/M\nGuinness/M\nGuiyang\nGuizot/M\nGujarat/M\nGujarati/M\nGujranwala/M\nGullah/M\nGulliver/M\nGun/M\nGunar/M\nGunderson/M\nGunilla/M\nGunnar/M\nGunner/M\nGuntar/M\nGunter/M\nGunther/M\nGuofeng/M\nGupta/M\nGurkha/M\nGus/M\nGusella/M\nGuss\nGussi/M\nGussie/M\nGussy/M\nGusta/M\nGustaf/M\nGustafson/M\nGustav/M\nGustave/M\nGustavo/M\nGustavus/M\nGusti/M\nGustie/M\nGusty/M\nGutenberg/M\nGuthrey/M\nGuthrie/M\nGuthry/M\nGutierrez/M\nGuy/M\nGuyana/M\nGuyanese\nGuzman/M\nGwalior/M\nGwen/M\nGwendolen/M\nGwendolin/M\nGwendoline/M\nGwendolyn/M\nGweneth/M\nGwenette/M\nGwenneth/M\nGwenni/M\nGwennie/M\nGwenny/M\nGwenora/M\nGwenore/M\nGwyn/M\nGwyneth/M\nGwynne/M\nGypsy/SM\nGdel/M\nGteborg/M\nH\nH's\nHBO/M\nHDTV\nHF\nHHS\nHI\nHIV\nHM\nHMO\nHMS\nHOV\nHP\nHQ\nHR\nHRH\nHS\nHST\nHTML\nHTTP\nHUD\nHa/M\nHaag/M\nHaas/M\nHabakkuk/M\nHaber/M\nHaberman/M\nHabib/M\nHackett/M\nHad/M\nHadamard/M\nHadar/M\nHaddad/M\nHades\nHadlee/M\nHadleigh/M\nHadley/M\nHadria/M\nHadrian/M\nHafiz/M\nHagan/M\nHagar/M\nHagen/M\nHager/M\nHaggai/M\nHagiographa/M\nHagstrom/M\nHague/M\nHahn/M\nHaifa/M\nHailee/M\nHailey/M\nHaily/M\nHaiphong/M\nHaiti/M\nHaitian/S\nHakeem/M\nHakim/M\nHakka/M\nHakluyt/M\nHal/SMY\nHaldane/M\nHale/M\nHaleakala/M\nHaleigh/M\nHalette/M\nHaley/M\nHali/M\nHalie/M\nHalifax/M\nHalimeda/M\nHall/M\nHalley/M\nHalli/M\nHallie/M\nHallinan/M\nHallmark/M\nHalloween/MS\nHallsy/M\nHally/M\nHalpern/M\nHalsey/M\nHalsy/M\nHam/M\nHamal/M\nHaman/M\nHamburg/MS\nHamel/M\nHamey/M\nHamhung/M\nHamid/M\nHamil/M\nHamilcar/M\nHamilton/M\nHamiltonian/MS\nHamish/M\nHamitic/M\nHamlen/M\nHamlet/M\nHamlin/M\nHammad/M\nHammarskjold/M\nHammerstein/M\nHammett/M\nHammond/M\nHammurabi/M\nHamnet/M\nHampshire/M\nHampton/M\nHamsun/M\nHan/SM\nHana/M\nHanan/M\nHancock/M\nHandel/M\nHandy/M\nHaney/M\nHangul/M\nHangzhou\nHank/M\nHankel/M\nHanna/M\nHannah/M\nHanni/MS\nHannibal/M\nHannie/M\nHanny/M\nHanoi/M\nHanover/M\nHanoverian\nHans/N\nHansel/M\nHansen/M\nHansiain/M\nHanson/M\nHanuka/S\nHanukkah/M\nHanukkahs\nHapgood/M\nHappy/M\nHapsburg/M\nHarald/M\nHarare\nHarbert/M\nHarbin/M\nHarcourt/M\nHardin/M\nHarding/M\nHardy/M\nHargreaves/M\nHarlan/M\nHarland/M\nHarlem/M\nHarlen/M\nHarlene/M\nHarlequin\nHarley/M\nHarli/M\nHarlie/M\nHarlin/M\nHarlow/M\nHarman/M\nHarmon/M\nHarmonia/M\nHarmonie/M\nHarmony/M\nHarold/M\nHaroun/M\nHarp/MR\nHarper/M\nHarpy/SM\nHarrell/M\nHarri/SM\nHarrie/M\nHarriet/M\nHarriett/M\nHarrietta/M\nHarriette/M\nHarrington/M\nHarriot/M\nHarriott/M\nHarrisburg/M\nHarrison/M\nHarrisonburg/M\nHarry/M\nHart/M\nHarte/M\nHartford/M\nHartley/M\nHartline/M\nHartman/M\nHartwell/M\nHarv/M\nHarvard/M\nHarvey/MS\nHarwell/M\nHarwilll/M\nHasbro/M\nHasheem/M\nHashim/M\nHasidim\nHaskel/M\nHaskell/M\nHaskins/M\nHaslett/M\nHastie/M\nHastings/M\nHasty/M\nHatchure/M\nHatfield/M\nHathaway/M\nHatteras/M\nHatti/M\nHattie/M\nHatty/M\nHaugen/M\nHauptmann/M\nHausa/M\nHausdorff/M\nHauser/M\nHavana/SM\nHavarti\nHavel/M\nHaven/M\nHaw\nHawaii/M\nHawaiian/S\nHawking\nHawkins/M\nHawley/M\nHawthorne/M\nHay/SM\nHayden/M\nHaydn/M\nHaydon/M\nHayes\nHayley/M\nHaynes\nHayward/M\nHaywood/M\nHayyim/M\nHaze/M\nHazel/M\nHazlett/M\nHazlitt/M\nHe/M\nHead/M\nHeall/M\nHearst/M\nHeartwood/M\nHeath/MR\nHeather/M\nHeathkit/M\nHeathman/M\nHeaviside/M\nHeb/M\nHebe/M\nHebert/M\nHebraic\nHebraism/MS\nHebrew/SM\nHebrides/M\nHecate/M\nHector/M\nHecuba/M\nHeda/M\nHedda/M\nHeddi/M\nHeddie/M\nHedi/M\nHedvig/M\nHedvige/M\nHedwig/M\nHedwiga/M\nHedy/M\nHeep/M\nHefner/M\nHegel/M\nHegelian\nHegira/M\nHeida/M\nHeidegger/M\nHeidelberg/M\nHeidi/M\nHeidie/M\nHeifetz/M\nHeimlich/M\nHeindrick/M\nHeine/M\nHeineken/M\nHeinlein/M\nHeinrich/M\nHeinrick/M\nHeinrik/M\nHeinz/M\nHeinze/M\nHeisenberg/M\nHeiser/M\nHejira's\nHelaina/M\nHelaine/M\nHelen/M\nHelena/M\nHelene/M\nHelenka/M\nHelga/M\nHelge/M\nHelicon/M\nHeliopolis/M\nHelios/M\nHell's\nHellene/SM\nHellenic\nHellenism/MS\nHellenist/MS\nHellenistic\nHellenization/M\nHellenize\nHeller/M\nHellespont/M\nHelli/M\nHellman/M\nHelmholtz/M\nHelmut/M\nHelsa/M\nHelsinki/M\nHelvetian/S\nHelvetius/M\nHelyn/M\nHemingway/M\nHench/M\nHenderson/M\nHendrick/SM\nHendrickson/M\nHendrik/M\nHendrika/M\nHendrix/M\nHenka/M\nHenley/M\nHennessey/M\nHenri/M\nHenrie/M\nHenrieta/M\nHenrietta/M\nHenriette/M\nHenrik/M\nHenry/M\nHenryetta/M\nHensley/M\nHenson/M\nHepburn/M\nHephaestus/M\nHephzibah/M\nHepplewhite\nHera/M\nHeracles/M\nHeraclitus/M\nHerb/M\nHerbart/M\nHerbert/M\nHerbie/M\nHerby/M\nHerc/M\nHerculaneum/M\nHercule/MS\nHerculean\nHerculie/M\nHerder/M\nHereford/SM\nHeriberto/M\nHerkimer/M\nHerman/M\nHermann/M\nHermaphroditus/M\nHermes\nHermia/M\nHermie/M\nHermina/M\nHermine/M\nHerminia/M\nHermione/M\nHermite/M\nHermon/M\nHermosa/M\nHermosillo/M\nHermy/M\nHernandez/M\nHernando/M\nHerod/M\nHerodotus/M\nHerold/M\nHerr/MG\nHerrera/M\nHerrick/M\nHerring/M\nHerrington/M\nHersch/M\nHerschel/M\nHersey/M\nHersh/M\nHershel/M\nHershey/M\nHerta/M\nHertha/M\nHertz/M\nHertzog/M\nHertzsprung/M\nHerve/M\nHervey/M\nHerzegovina/M\nHerzl/M\nHesiod/M\nHesperus/M\nHess/M\nHesse/M\nHessian/MS\nHester/M\nHesther/M\nHestia/M\nHeston/M\nHetti/M\nHettie/M\nHetty/M\nHeublein/M\nHeusen/M\nHeuser/M\nHew/M\nHewe/M\nHewet/M\nHewett/M\nHewie/M\nHewitt/M\nHewlett/M\nHeyerdahl/M\nHeywood/M\nHezekiah/M\nHf/M\nHg/M\nHi/M\nHialeah/M\nHiawatha/M\nHibernia/M\nHibernian/S\nHickey/SM\nHickman/M\nHickok/M\nHicks/M\nHieronymus/M\nHigashiosaka\nHiggins/M\nHighfield/M\nHighlander/SM\nHighlands\nHighness/M\nHilario/M\nHilarius/M\nHilary/M\nHilbert/M\nHilda/M\nHildagard/M\nHildagarde/M\nHilde/M\nHildebrand/M\nHildegaard/M\nHildegarde/M\nHildy/M\nHill/M\nHillard/M\nHillary/M\nHillcrest/M\nHillel/M\nHillery/M\nHilliard/M\nHilliary/M\nHillie/M\nHillier/M\nHillsboro/M\nHillsdale/M\nHilly/RM\nHillyer/M\nHilton/M\nHimalaya/MS\nHimalayan/S\nHimmler/M\nHinayana/M\nHinda/M\nHindemith/M\nHindenburg/M\nHindi/M\nHindu/MS\nHinduism/SM\nHindustan/M\nHindustani/MS\nHines/M\nHinkle/M\nHinsdale/M\nHinton/M\nHinze/M\nHipparchus/M\nHippocrates/M\nHippocratic\nHiram/M\nHirey/M\nHirohito/M\nHiroshi/M\nHiroshima/M\nHirsch/M\nHispanic/SM\nHispaniola/M\nHiss/M\nHitachi/M\nHitchcock/M\nHitler/SM\nHittite/SM\nHmong\nHo/M\nHobard/M\nHobart/M\nHobbes/M\nHobbs/M\nHobday/M\nHobey/M\nHobie/M\nHoboken/M\nHockney/M\nHodge/MS\nHodgkin/M\nHoebart/M\nHoff/M\nHoffa/M\nHoffman/M\nHofstadter/M\nHogan/M\nHogarth/M\nHohenlohe/M\nHohenstaufen/M\nHohenzollern/M\nHohhot/M\nHokkaido/M\nHokusai/M\nHolbein/M\nHolbrook/M\nHolcomb/M\nHolden/M\nHolder/M\nHoliday/M\nHoliness/MS\nHolland/RMSZ\nHollandaise/M\nHollander/M\nHollerith/M\nHolley/M\nHolli/SM\nHollie/M\nHollister/M\nHolloway/M\nHolly/M\nHollyanne/M\nHollywood/M\nHolm/M\nHolman/M\nHolmes\nHolocaust\nHolocene\nHolst/M\nHolstein/MS\nHolt/M\nHolyoke/M\nHolzman/M\nHom/MR\nHomer/M\nHomere/M\nHomeric\nHomerus/M\nHon/M\nHonda/M\nHondo/M\nHonduran/S\nHonduras/M\nHonecker/M\nHoney/M\nHoneywell/M\nHoniara/M\nHonolulu/M\nHonor/M\nHonoria/M\nHonshu/M\nHood/M\nHooke/MR\nHooker/M\nHooper/M\nHoosier/SM\nHoover/MS\nHope/M\nHopewell/M\nHopi/SM\nHopkins/M\nHopkinsian/M\nHopper/M\nHorace/M\nHoracio/M\nHoratia/M\nHoratio/M\nHoratius/M\nHormel/M\nHormuz/M\nHorn/M\nHornblower/M\nHorne/M\nHorowitz/M\nHorst/M\nHort/MN\nHorten/M\nHortense/M\nHortensia/M\nHorton/M\nHorus/M\nHosea/M\nHost/MS\nHottentot/SM\nHoudaille/M\nHoudini/M\nHouse/M\nHousman/M\nHouston/M\nHouyhnhnm/M\nHoward/M\nHowe/M\nHowell/MS\nHowey/M\nHowie/M\nHowrah/M\nHoyle/SM\nHoyt/M\nHrothgar/M\nHts/M\nHuang/M\nHubbard/M\nHubble/M\nHube/RM\nHuber/M\nHubert/M\nHuberto/M\nHubey/M\nHubie/M\nHuck/M\nHuddersfield/M\nHudson/M\nHuerta/M\nHuey/M\nHuff/M\nHuffman/M\nHuggins\nHugh/MS\nHughie/M\nHugibert/M\nHugo/M\nHuguenot/SM\nHugues/M\nHui/M\nHuitzilopitchli/M\nHulda/M\nHull/M\nHumbert/M\nHumberto/M\nHumboldt/M\nHume/M\nHumfrey/M\nHumfrid/M\nHumfried/M\nHummel/M\nHumphrey/SM\nHumpty/M\nHumvee\nHun/MS\nHunfredo/M\nHung/M\nHungarian/MS\nHungary/M\nHunt/MR\nHunter/M\nHuntington/M\nHuntlee/M\nHuntley/M\nHuntsville/M\nHurlee/M\nHurleigh/M\nHurley/M\nHuron/SM\nHurst/M\nHurwitz/M\nHus\nHusain's\nHusein/M\nHussein/M\nHusserl/M\nHuston/M\nHutchins/M\nHutchinson/M\nHutchison/M\nHutton/M\nHutu/M\nHuxley/M\nHuygens/M\nHy/M\nHyacinth/M\nHyacintha/M\nHyacinthe/M\nHyacinthia/M\nHyacinthie/M\nHyades\nHyannis/M\nHyatt/M\nHyde/M\nHyderabad/M\nHydra/M\nHyman/M\nHymen/M\nHymie/M\nHynda/M\nHyperion/M\nHyundai/M\nHz\nHloise/M\nI\nI'd\nI'll\nI'm\nI've\nIA\nIBM/M\nICBM/S\nICC\nICU\nID\nIDs\nIE\nIEEE\nIL\nIMF\nIMHO\nIMNSHO\nIMO\nIN\nINRI\nINS\nINTERNET/M\nIOU\nIPA\nIQ\nIRA/S\nIRS\nISBN\nISO\nIT\nITCorp/M\nITT\nITcorp/M\nIUD/S\nIV\nIVs\nIa/M\nIaccoca/M\nIago/M\nIain/M\nIan/M\nIanthe/M\nIbadan/M\nIbbie/M\nIbby/M\nIberia/M\nIberian/MS\nIbero/M\nIbo/M\nIbrahim/M\nIbsen/M\nIcarus/M\nIce/M\nIceland/MRZ\nIcelander/M\nIcelandic\nIchabod/M\nIda/M\nIdaho/MS\nIdahoan/S\nIdahoes\nIdalia/M\nIdalina/M\nIdaline/M\nIdell/M\nIdelle/M\nIdette/M\nIeyasu/M\nIfni/M\nIggie/M\nIggy/M\nIgnace/M\nIgnacio/M\nIgnacius/M\nIgnatius/M\nIgnaz/M\nIgnazio/M\nIgor/M\nIguassu/M\nIjsselmeer/M\nIke/M\nIkey/M\nIkhnaton/M\nIla/M\nIlaire/M\nIlario/M\nIleana/M\nIleane/M\nIlene/M\nIliad/MS\nIlise/M\nIlka/M\nIll/M\nIlla/M\nIllinois/M\nIllinoisan/MS\nIlluminati\nIlona/M\nIlsa/M\nIlse/M\nIlysa/M\nIlyse/M\nIlyssa/M\nIlyushin/M\nImagen/M\nImbrium/M\nImelda/M\nImmanuel/M\nImogen/M\nImogene/M\nImojean/M\nImus/M\nIn/PM\nIna/M\nInc/M\nInca/SM\nInchon/M\nInd/M\nIndependence/M\nIndia/M\nIndian/SM\nIndiana/M\nIndianan/S\nIndianapolis/M\nIndianian/S\nIndira/M\nIndochina/M\nIndochinese\nIndonesia/M\nIndonesian/S\nIndore/M\nIndra/M\nIndus/M\nIndy/SM\nInes\nInesita/M\nInessa/M\nInez/M\nInformatica/M\nInga/M\nIngaberg/M\nIngaborg/M\nIngamar/M\nIngar/M\nInge/RM\nIngeberg/M\nIngeborg/M\nIngelbert/M\nIngemar/M\nInger/M\nIngersoll/M\nInglebert/M\nInglewood/M\nInglis/M\nIngmar/M\nIngra/M\nIngram/M\nIngres/M\nIngrid/M\nIngrim/M\nIngunna/M\nInigo/M\nInna/M\nInnis/M\nInnocent/M\nInnsbruck/M\nInonu/M\nInquisition/MS\nInst\nIntel/M\nIntelsat/M\nInterdata/M\nInternationale/M\nInternet/M\nInterpol/M\nInuit/MS\nInverness/M\nIo/M\nIolande/M\nIolanthe/M\nIona/M\nIonesco/M\nIonian/M\nIonic/S\nIorgo/MS\nIormina/M\nIosep/M\nIowa/SM\nIowan/S\nIphigenia/M\nIpswich/M\nIqbal/M\nIquitos/M\nIr/M\nIra/M\nIran/M\nIranian/MS\nIraq/M\nIraqi/SM\nIreland/M\nIrena/M\nIrene/M\nIrina/M\nIris\nIrish/R\nIrishman/M\nIrishmen\nIrishwoman/M\nIrishwomen\nIrita/M\nIrkutsk/M\nIrma/M\nIroquoian/MS\nIroquois/M\nIrrawaddy/M\nIrtish/M\nIrv/MG\nIrvin/M\nIrvine/M\nIrving/M\nIrwin/M\nIrwinn/M\nIsa/M\nIsaac/SM\nIsaak/M\nIsabel/M\nIsabelita/M\nIsabella/M\nIsabelle/M\nIsac/M\nIsacco/M\nIsador/M\nIsadora/M\nIsadore/M\nIsahella/M\nIsaiah/M\nIsak/M\nIscariot/M\nIseabal/M\nIsfahan/M\nIsherwood/M\nIshim/M\nIshmael/M\nIshtar/M\nIsiah/M\nIsiahi/M\nIsidor/M\nIsidora/M\nIsidore/M\nIsidoro/M\nIsidro/M\nIsis/M\nIslam/SM\nIslamabad/M\nIslamic/S\nIslandia/M\nIsmael/M\nIsobel/M\nIsolde/M\nIspahan's\nIspell/M\nIsrael/MS\nIsraeli/MS\nIsraelite/SM\nIssac/M\nIssi/M\nIssiah/M\nIssie/M\nIssy/M\nIstanbul/M\nIstvan/M\nIsuzu/M\nIt\nItaipu/M\nItal/M\nItalian/MS\nItalianate/GSD\nItaly/M\nItasca/M\nItch/M\nItel/M\nIthaca/M\nIthacan\nIto/M\nIva/M\nIvan/M\nIvanhoe/M\nIvar/M\nIve/MRS\nIver/M\nIvett/M\nIvette/M\nIvie/M\nIvonne/M\nIvor/M\nIvory/M\nIvy/M\nIzaak/M\nIzabel/M\nIzak/M\nIzanagi/M\nIzanami/M\nIzhevsk/M\nIzmir/M\nIzvestia/M\nIzzy/M\nJ's\nJ/X\nJCS\nJD\nJFK/M\nJP\nJV\nJabez/M\nJablonsky/M\nJacenta/M\nJacinda/M\nJacinta/M\nJacintha/M\nJacinthe/M\nJack/M\nJackelyn/M\nJacki/M\nJackie/M\nJacklin/M\nJacklyn/M\nJackman/M\nJackquelin/M\nJackqueline/M\nJackson/SM\nJacksonian\nJacksonville/M\nJacky/M\nJaclin/M\nJaclyn/M\nJacob/SM\nJacobean\nJacobi/M\nJacobian/M\nJacobin/M\nJacobite/M\nJacobo/M\nJacobs/N\nJacobsen/M\nJacobson/M\nJacobus\nJacoby/M\nJacquard/SM\nJacquelin/M\nJacqueline/M\nJacquelyn/M\nJacquelynn/M\nJacquenetta/M\nJacquenette/M\nJacques/M\nJacquetta/M\nJacquette/M\nJacqui/M\nJacquie/M\nJacuzzi/S\nJacynth/M\nJada/M\nJade/M\nJae/M\nJaeger/M\nJagger/M\nJaime/M\nJaimie/M\nJain/M\nJaine/M\nJainism/M\nJaipur/M\nJakarta/M\nJake/MS\nJakie/M\nJakob/M\nJamaal/M\nJamaica/M\nJamaican/S\nJamal/M\nJamar/M\nJame/MS\nJamel/M\nJameson/M\nJamestown/M\nJamesy/M\nJamey/M\nJami/M\nJamie/M\nJamil/M\nJamill/M\nJamima/M\nJamison/M\nJammal/M\nJammie/M\nJan/M\nJana/M\nJanacek/M\nJanaya/M\nJanaye/M\nJandy/M\nJane/M\nJanean/M\nJaneczka/M\nJaneen/M\nJaneiro/M\nJanek/M\nJanel/M\nJanela/M\nJanell/M\nJanella/M\nJanelle/M\nJanene/M\nJanenna/M\nJanessa/M\nJanesville/M\nJanet/M\nJaneta/M\nJanetta/M\nJanette/M\nJaneva/M\nJaney/M\nJania/M\nJanice/M\nJanie/M\nJanifer/M\nJanina/M\nJanine/M\nJanis/M\nJanith/M\nJanka/M\nJanna/M\nJannel/M\nJannelle/M\nJannie/M\nJanos/M\nJanot/M\nJansen/M\nJansenist/M\nJanuary/MS\nJanus/M\nJany/M\nJapan/M\nJapanese/SM\nJapura/M\nJaquelin/M\nJaquelyn/M\nJaquenetta/M\nJaquenette/M\nJaquith/M\nJarad/M\nJard/M\nJareb/M\nJared/M\nJarib/M\nJarid/M\nJarlsberg\nJarrad/M\nJarred/M\nJarret/M\nJarrett/M\nJarrid/M\nJarrod/M\nJarvis/M\nJase/M\nJasen/M\nJasmin/M\nJasmina/M\nJasmine/M\nJason/M\nJasper/M\nJastrow/M\nJasun/M\nJava/SM\nJavaScript/M\nJavanese\nJavier/M\nJaxartes/M\nJay/M\nJayapura/M\nJaycee/SM\nJaye/M\nJayme/M\nJaymee/M\nJaymie/M\nJayne/M\nJaynell/M\nJayson/M\nJazmin/M\nJdavie/M\nJean/M\nJeana/M\nJeane/M\nJeanelle/M\nJeanette/M\nJeanie/M\nJeanine/M\nJeanna/M\nJeanne/M\nJeannette/M\nJeannie/M\nJeannine/M\nJecho/M\nJed/M\nJedd/M\nJeddy/M\nJedediah/M\nJedi/M\nJedidiah/M\nJeep/S\nJeeves/M\nJeff/M\nJefferey/M\nJefferson/M\nJeffersonian/S\nJeffery/M\nJeffie/M\nJeffrey/SM\nJeffry/M\nJeffy/M\nJehanna/M\nJehoshaphat/M\nJehovah/M\nJehu/M\nJekyll/M\nJelene/M\nJello/M\nJemie/M\nJemima/M\nJemimah/M\nJemmie/M\nJemmy/M\nJen/M\nJena/M\nJenda/M\nJenelle/M\nJeni/M\nJenica/M\nJeniece/M\nJenifer/M\nJeniffer/M\nJenilee/M\nJenine/M\nJenkins/M\nJenn/RMJ\nJenna/M\nJennee/M\nJenner/M\nJennette/M\nJenni/M\nJennica/M\nJennie/M\nJennifer/M\nJennilee/M\nJennine/M\nJennings/M\nJenny/M\nJeno/M\nJens/N\nJensen/M\nJephthah/M\nJerad/M\nJerald/M\nJeralee/M\nJeramey/M\nJeramie/M\nJere/M\nJereme/M\nJeremiah/M\nJeremiahs\nJeremias/M\nJeremie/M\nJeremy/M\nJeri/M\nJericho/M\nJermain/M\nJermaine/M\nJermayne/M\nJeroboam/M\nJerold/M\nJerome/M\nJeromy/M\nJerri/M\nJerrie/M\nJerrilee/M\nJerrilyn/M\nJerrine/M\nJerrod/M\nJerrold/M\nJerrome/M\nJerry/M\nJerrylee/M\nJersey/MS\nJerusalem/M\nJervis/M\nJes\nJess/M\nJessa/M\nJessalin/M\nJessalyn/M\nJessamine/M\nJessamyn/M\nJesse/M\nJessee/M\nJesselyn/M\nJessey/M\nJessi/M\nJessica/M\nJessie/M\nJessika/M\nJessy/M\nJesuit/SM\nJesus\nJeth/M\nJethro/M\nJew/MS\nJewel/M\nJewell/MD\nJewelle/M\nJewelled/M\nJewess/SM\nJewish/P\nJewishness/MS\nJewry/MS\nJezebel/MS\nJidda/M\nJilin\nJill/M\nJillana/M\nJillane/M\nJillayne/M\nJilleen/M\nJillene/M\nJilli/M\nJillian/M\nJillie/M\nJilly/M\nJim/M\nJimenez/M\nJimmie/M\nJimmy/M\nJinan\nJinnah/M\nJinny/M\nJivaro/M\nJo/MY\nJoachim/M\nJoan/M\nJoana/M\nJoane/M\nJoanie/M\nJoann/M\nJoanna/M\nJoanne/SM\nJoaquin/M\nJob/SM\nJobey/M\nJobi/M\nJobie/M\nJobina/M\nJobrel/M\nJoby/M\nJobye/M\nJobyna/M\nJocasta/M\nJocelin/M\nJoceline/M\nJocelyn/M\nJocelyne/M\nJock/M\nJocko/M\nJodee/M\nJodi/M\nJodie/M\nJody/M\nJoe/M\nJoeann/M\nJoel/MY\nJoela/M\nJoelie/M\nJoell/MN\nJoella/M\nJoelle/M\nJoellen/M\nJoelly/M\nJoellyn/M\nJoelynn/M\nJoesph/M\nJoete/M\nJoey/M\nJogjakarta/M\nJohan/M\nJohann/M\nJohanna/M\nJohannah/M\nJohannes\nJohannesburg/M\nJohansen/M\nJohanson/M\nJohn/SM\nJohna/MH\nJohnath/M\nJohnathan/M\nJohnathon/M\nJohnette/M\nJohnie/M\nJohnna/M\nJohnnie/M\nJohnny/M\nJohns/N\nJohnsen/M\nJohnson/M\nJohnston/M\nJohnstown/M\nJohny/M\nJoice/M\nJojo/M\nJolee/M\nJoleen/M\nJolene/M\nJoletta/M\nJoli/M\nJolie/M\nJoliet's\nJoline/M\nJolla/M\nJolson/M\nJoly/M\nJolyn/M\nJolynn/M\nJon/M\nJonah/M\nJonahs\nJonas\nJonathan/M\nJonathon/M\nJone/MS\nJonell/M\nJones/S\nJoni/MS\nJonie/M\nJonson/M\nJoplin/M\nJordain/M\nJordan/M\nJordana/M\nJordanian/S\nJordanna/M\nJordon/M\nJorey/M\nJorgan/M\nJorge/M\nJorgensen/M\nJorgenson/M\nJori/M\nJorie/M\nJorrie/M\nJorry/M\nJory/M\nJoscelin/M\nJose/M\nJosee/M\nJosef/M\nJosefa/M\nJosefina/M\nJoseito/M\nJoseph/M\nJosepha/M\nJosephina/M\nJosephine/M\nJosephs\nJosephson/M\nJosephus/M\nJosey/M\nJosh/M\nJoshia/M\nJoshua/M\nJoshuah/M\nJosi/M\nJosiah/M\nJosias/M\nJosie/M\nJosselyn/M\nJosue/M\nJosy/M\nJoule/M\nJourdain/M\nJourdan/M\nJovanovich/M\nJove/M\nJovian\nJoy/M\nJoya/M\nJoyan/M\nJoyann/M\nJoyce/M\nJoycean\nJoycelin/M\nJoye/M\nJoyner/M\nJozef/M\nJpn\nJr/M\nJsandye/M\nJuan/M\nJuana/M\nJuanita/M\nJuarez\nJubal/M\nJud/M\nJudah/M\nJudaic\nJudaical\nJudaism/SM\nJudas/S\nJudd/M\nJude/M\nJudea/M\nJudi/MH\nJudie/M\nJudith/M\nJuditha/M\nJudon/M\nJudson/M\nJudy/M\nJudye/M\nJuggernaut/M\nJuieta/M\nJul/M\nJule/MS\nJulee/M\nJuli/M\nJulia/M\nJulian/M\nJuliana/M\nJuliane/M\nJuliann/M\nJulianna/M\nJulianne/M\nJulie/M\nJulienne/M\nJuliet/M\nJulieta/M\nJulietta/M\nJuliette/M\nJulina/M\nJuline/M\nJulio/M\nJulissa/M\nJulita/M\nJulius/M\nJuly/SM\nJulys\nJun/M\nJune/MS\nJuneau/M\nJunette/M\nJung/M\nJungfrau/M\nJungian\nJunia/M\nJunie/M\nJunina/M\nJunior/S\nJunker/SM\nJuno/M\nJupiter/M\nJurassic\nJurua/M\nJusten/M\nJustice/M\nJustin/M\nJustina/M\nJustine/M\nJustinian/M\nJustinn/M\nJustino/M\nJustis/M\nJustus/M\nJutish\nJutland/M\nJuvenal/M\nJyoti/M\nK's\nK/G\nKB\nKC\nKDE/M\nKGB\nKIA\nKKK\nKO\nKP\nKS\nKY\nKaaba/M\nKabuki\nKabul/M\nKacey/M\nKacie/M\nKacy/M\nKaddish/M\nKaela/M\nKafka/M\nKafkaesque\nKagoshima/M\nKahaleel/M\nKahlil/M\nKahlua/M\nKahn/M\nKai/M\nKaia/M\nKaifeng/M\nKaila/M\nKaile/M\nKailey/M\nKain/M\nKaine/M\nKaiser/SM\nKaitlin/M\nKaitlyn/M\nKaitlynn/M\nKaja/M\nKajar/M\nKakalina/M\nKala/M\nKalahari/M\nKalamazoo/M\nKalashnikov/M\nKalb/M\nKale/M\nKaleb/M\nKaleena/M\nKalgoorlie/M\nKali/M\nKalie/M\nKalil/M\nKalila/M\nKalina/M\nKalinda/M\nKalindi/M\nKalle/M\nKalli/M\nKally/M\nKalmyk\nKalvin/M\nKama/M\nKamchatka/M\nKamehameha/M\nKameko/M\nKamikaze/MS\nKamila/M\nKamilah/M\nKamillah/M\nKampala/M\nKampuchea/M\nKan/MS\nKanchenjunga/M\nKandace/M\nKandahar/M\nKandinsky/M\nKandy/M\nKane/M\nKania/M\nKankakee/M\nKannada/M\nKano/M\nKanpur/M\nKansan/S\nKansas\nKant/M\nKantian\nKanya/M\nKaohsiung/M\nKaplan/M\nKaposi/M\nKara/M\nKarachi/M\nKaraganda/M\nKarakorum/M\nKaralee/M\nKaralynn/M\nKaramazov/M\nKare/M\nKaree/M\nKareem/M\nKarel/M\nKaren/M\nKarena/M\nKarenina/M\nKari/M\nKaria/M\nKarie/M\nKaril/M\nKarilynn/M\nKarim/M\nKarin/M\nKarina/M\nKarine/M\nKariotta/M\nKarisa/M\nKarissa/M\nKarita/M\nKarl/MNX\nKarla/M\nKarlan/M\nKarlee/M\nKarleen/M\nKarlen/M\nKarlene/M\nKarlie/M\nKarlik/M\nKarlis\nKarloff/M\nKarlotta/M\nKarlotte/M\nKarly/M\nKarlyn/M\nKarmen/M\nKarna/M\nKarney/M\nKaro/YM\nKarol/M\nKarola/M\nKarole/M\nKarolina/M\nKaroline/M\nKaroly/M\nKaron/M\nKarp/M\nKarrah/M\nKarrie/M\nKarroo/M\nKarry/M\nKary/M\nKaryl/M\nKarylin/M\nKaryn/M\nKasai/M\nKasey/M\nKashmir/SM\nKaspar/M\nKasparov/M\nKasper/M\nKass\nKassandra/M\nKassey/M\nKassi/M\nKassia/M\nKassie/M\nKat/M\nKata/M\nKatalin/M\nKate/M\nKatee/M\nKatelyn/M\nKaterina/M\nKaterine/M\nKatey/M\nKath/M\nKatha/M\nKatharina/M\nKatharine/M\nKatharyn/M\nKathe/M\nKatherina/M\nKatherine/M\nKatheryn/M\nKathi/M\nKathiawar/M\nKathie/M\nKathleen/M\nKathlin/M\nKathmandu\nKathrine/M\nKathryn/M\nKathryne/M\nKathy/M\nKathye/M\nKati/M\nKatie/M\nKatina/M\nKatine/M\nKatinka/M\nKatleen/M\nKatlin/M\nKatmai/M\nKatmandu's\nKatowice/M\nKatrina/M\nKatrine/M\nKatrinka/M\nKatti/M\nKattie/M\nKatuscha/M\nKatusha/M\nKaty/M\nKatya/M\nKatz/M\nKauai/M\nKauffman/M\nKaufman/M\nKaunas/M\nKaunda/M\nKawabata/M\nKawasaki/M\nKay/M\nKaycee/M\nKaye/M\nKayla/M\nKayle/M\nKaylee/M\nKayley/M\nKaylil/M\nKaylyn/M\nKayne/M\nKazakh/M\nKazakhstan\nKazan/M\nKazantzakis/M\nKb\nKean/M\nKeane/M\nKearney/M\nKeary/M\nKeaton/M\nKeats/M\nKeck/M\nKeefe/MR\nKeefer/M\nKeegan/M\nKeelby/M\nKeeley/M\nKeelia/M\nKeely/M\nKeen/M\nKeenan/M\nKeene/M\nKeewatin/M\nKeillor/M\nKeir/M\nKeisha/M\nKeith/M\nKelbee/M\nKelby/M\nKelcey/M\nKelci/M\nKelcie/M\nKelcy/M\nKele/M\nKelila/M\nKellby/M\nKellen/M\nKeller/M\nKelley/M\nKelli/M\nKellia/M\nKellie/M\nKellina/M\nKellogg/M\nKellsie/M\nKelly/M\nKellyann/M\nKelsey/M\nKelsi/M\nKelsy/M\nKelt's\nKelvin/M\nKelwin/M\nKemerovo/M\nKemp/M\nKempis/M\nKen/M\nKendal/M\nKendall/M\nKendell/M\nKendra/M\nKendre/M\nKendrick/MS\nKenilworth/M\nKenmore/M\nKenn/M\nKenna/M\nKennan/M\nKennecott/M\nKennedy/M\nKenneth/M\nKennett/M\nKennie/M\nKennith/M\nKenny/M\nKenon/M\nKenosha/M\nKensington/M\nKent/M\nKenton/M\nKentuckian/S\nKentucky/M\nKenya/M\nKenyan/S\nKenyatta/M\nKenyon/M\nKeogh/M\nKeokuk/M\nKepler/M\nKer/M\nKerby/M\nKerensky/M\nKeri/M\nKeriann/M\nKerianne/M\nKerk/M\nKermie/M\nKermit/M\nKermy/M\nKern/M\nKerouac/M\nKerr/M\nKerri/M\nKerrie/M\nKerrill/M\nKerrin/M\nKerry/M\nKerstin/M\nKerwin/M\nKerwinn/M\nKesley/M\nKeslie/M\nKessia/M\nKessiah/M\nKessler/M\nKettering/M\nKetti/M\nKettie/M\nKetty/M\nKev/MN\nKevan/M\nKeven/M\nKevin/M\nKevina/M\nKevlar\nKevon/M\nKevorkian/M\nKevyn/M\nKewaskum/M\nKewaunee/M\nKewpie/M\nKey/M\nKeynes/M\nKeynesian/M\nKhabarovsk/M\nKhachaturian/M\nKhalid/M\nKhalil/M\nKhan/M\nKharkov/M\nKhartoum/M\nKhayyam/M\nKhmer/M\nKhoisan/M\nKhomeini/M\nKhorana/M\nKhrushchev/SM\nKhufu/M\nKhulna/M\nKhwarizmi/M\nKhyber/M\nKi/M\nKiah/M\nKial/M\nKickapoo/M\nKidd/M\nKieffer/M\nKiel/M\nKiele/M\nKienan/M\nKierkegaard/M\nKiersten/M\nKieth/M\nKiev/M\nKigali/M\nKikelia/M\nKikuyu/M\nKilauea/M\nKile/M\nKiley/M\nKilian/M\nKilimanjaro/M\nKillebrew/M\nKillian/M\nKillie/M\nKilly/M\nKim/M\nKimball/M\nKimbell/M\nKimberlee/M\nKimberley/M\nKimberli/M\nKimberly/M\nKimberlyn/M\nKimble/M\nKimbra/M\nKimmi/M\nKimmie/M\nKimmy/M\nKin/M\nKincaid/M\nKing/M\nKingsbury/M\nKingsley/M\nKingsly/M\nKingston/M\nKingstown/M\nKingwood/M\nKinna/M\nKinney/M\nKinnickinnic/M\nKinnie/M\nKinny/M\nKinsey/M\nKinshasa/M\nKinshasha/M\nKinsley/M\nKiowa/SM\nKip/M\nKipling/M\nKipp/MR\nKippar/M\nKipper/M\nKippie/M\nKippy/M\nKira/M\nKirbee/M\nKirbie/M\nKirby/M\nKirchhoff/M\nKirchner/M\nKirchoff/M\nKirghistan/M\nKirghiz/M\nKirghizia/M\nKiri/M\nKiribati\nKirinyaga/M\nKirk/M\nKirkland/M\nKirkpatrick/M\nKirkwood/M\nKirov/M\nKirsten/M\nKirsteni/M\nKirsti/M\nKirstin/M\nKirstyn/M\nKisangani/M\nKishinev/M\nKissee/M\nKissiah/M\nKissie/M\nKissinger/M\nKit/M\nKitakyushu/M\nKitchener/M\nKitti/M\nKittie/M\nKitty/M\nKiwanis/M\nKizzee/M\nKizzie/M\nKlan/M\nKlansman/M\nKlara/M\nKlarika/M\nKlarrisa/M\nKlaus/M\nKlee/M\nKleenex/SM\nKlein/M\nKleinrock/M\nKlemens/M\nKlement/M\nKleon/M\nKliment/M\nKline/M\nKlingon/M\nKlondike/SDMG\nKlux/M\nKnapp/M\nKnauer/M\nKnesset/M\nKngwarreye/M\nKnickerbocker/MS\nKnievel/M\nKnight/M\nKnobeloch/M\nKnopf/M\nKnossos/M\nKnowles\nKnox/M\nKnoxville/M\nKnudsen/M\nKnudson/M\nKnuth/M\nKnutsen/M\nKnutson/M\nKobayashi/M\nKobe/M\nKoch/M\nKochab/M\nKodachrome/M\nKodak/SM\nKodaly/M\nKodiak/M\nKoenig/M\nKoenigsberg/M\nKoenraad/M\nKoestler/M\nKohinoor/M\nKohl/MR\nKohler/M\nKolyma/M\nKommunizma/M\nKong/M\nKongo/M\nKonrad/M\nKonstance/M\nKonstantin/M\nKonstantine/M\nKonstanze/M\nKoo/M\nKoontz/M\nKoppers/M\nKora/M\nKoral/M\nKoralle/M\nKoran/SM\nKoranic\nKordula/M\nKore/M\nKorea/M\nKorean/S\nKorella/M\nKoren/M\nKoressa/M\nKorey/M\nKori/M\nKorie/M\nKornberg/M\nKorney/M\nKorrie/M\nKorry/M\nKort/M\nKory/M\nKorzybski/M\nKosciusko/M\nKossuth/M\nKosygin/M\nKovacs/M\nKowalewski/M\nKowalski/M\nKowloon/M\nKr/M\nKraemer/M\nKraft/M\nKrakatau's\nKrakatoa/M\nKrakow/M\nKramer/M\nKrasnodar/M\nKrasnoyarsk/M\nKrause/M\nKrebs/M\nKremlin/M\nKremlinologist/MS\nKremlinology/MS\nKresge/M\nKrieger/M\nKringle/M\nKris/M\nKrisha/M\nKrishna/M\nKrishnah/M\nKrispin/M\nKrissie/M\nKrissy/M\nKrista/M\nKristal/M\nKristan/M\nKriste/M\nKristel/M\nKristen/M\nKristi/MN\nKristian/M\nKristie/M\nKristien/M\nKristin/M\nKristina/M\nKristine/M\nKristo/MS\nKristofer/M\nKristoffer/M\nKristofor/M\nKristoforo/M\nKristopher/M\nKristy/M\nKristyn/M\nKroc/M\nKroger/M\nKronecker/M\nKropotkin/M\nKrueger/M\nKruger/M\nKrugerrand/S\nKrupp/M\nKruse/M\nKrysta/M\nKrystal/M\nKrystalle/M\nKrystle/M\nKrystyna/M\nKu/M\nKublai/M\nKubrick/M\nKubuntu\nKubuntu's\nKuenning/M\nKuhn/M\nKuibyshev/M\nKumar/M\nKunming/M\nKuomintang/M\nKurd/SM\nKurdish/M\nKurdistan/SM\nKurosawa/M\nKurt/M\nKurtis/M\nKusch/M\nKuwait/M\nKuwaiti/SM\nKuznets/M\nKuznetsk/M\nKwakiutl/M\nKwangchow's\nKwangju/M\nKwanzaa/S\nKy/MH\nKyla/M\nKyle/M\nKylen/M\nKylie/M\nKylila/M\nKylynn/M\nKym/M\nKynthia/M\nKyoto/M\nKyrgyzstan\nKyrstin/M\nKyushu/M\nL\nL'Amour\nL'Ouverture\nL's\nL'vov\nLA\nLAN\nLBJ/M\nLC\nLCD\nLCM\nLDC\nLED/SM\nLIFO\nLL\nLLB\nLLD\nLNG\nLOGO\nLP\nLPG\nLPN/S\nLSD\nLa/M\nLaTeX/M\nLab/SM\nLaban/M\nLabrador/SM\nLabradorean/S\nLac/M\nLacee/M\nLacey/M\nLachesis/M\nLacie/M\nLackawanna/M\nLacy/M\nLadoga/M\nLadonna/M\nLady/SM\nLadyship/MS\nLaetitia/M\nLafayette/M\nLafitte/M\nLagos/M\nLagrange/M\nLagrangian/M\nLaguerre/M\nLaguna/M\nLahore/M\nLaidlaw/M\nLaina/M\nLainey/M\nLaird/M\nLaius/M\nLakehurst/M\nLakeisha/M\nLakewood/M\nLakisha/M\nLakshmi/M\nLalo/M\nLamaism/SM\nLamar/M\nLamarck/M\nLamaze\nLamb/M\nLambert/M\nLamborghini/M\nLammond/M\nLamond/M\nLamont/M\nLamport/M\nLana/M\nLanae/M\nLanai/M\nLancashire/M\nLancaster/M\nLance/M\nLancelot/M\nLand/M\nLandis/M\nLandon/M\nLandry/M\nLandsat\nLandsteiner/M\nLandwehr/M\nLane/M\nLanette/M\nLaney/M\nLang/M\nLange/M\nLangeland/M\nLangerhans/M\nLangford/M\nLangland/M\nLangley/M\nLangmuir/M\nLangsdon/M\nLangston/M\nLani/M\nLanie/M\nLanita/M\nLanna/M\nLanni/M\nLannie/M\nLanny/M\nLansing/M\nLanzhou\nLao/SM\nLaocoon/M\nLaotian/MS\nLaplace/M\nLapland/ZMR\nLapp/SM\nLara/M\nLaraine/M\nLaramie/M\nLardner/M\nLaredo/M\nLari/M\nLarina/M\nLarine/M\nLarisa/M\nLarissa/M\nLark/M\nLarousse/M\nLarry/M\nLars/NM\nLarsen/M\nLarson/M\nLaryssa/M\nLascaux/M\nLassa/M\nLassen/M\nLassie/M\nLaszlo/M\nLat/M\nLatasha/M\nLatashia/M\nLateran/M\nLathrop/M\nLatia/M\nLatin/RMS\nLatina/SM\nLatinate\nLatino/S\nLatisha/M\nLatonya/M\nLatoya/M\nLatrena/M\nLatrina/M\nLatrobe/M\nLattimer/M\nLatvia/M\nLatvian/S\nLaud/MR\nLauder/M\nLauderdale/M\nLaue/M\nLaughton/M\nLaunce/M\nLaundromat/SM\nLaura/M\nLauraine/M\nLaural/M\nLauralee/M\nLaurasia/M\nLaure/M\nLauree/M\nLaureen/M\nLaurel/M\nLaurella/M\nLauren/SM\nLaurena/M\nLaurence/M\nLaurene/M\nLaurent/M\nLaurentian\nLauretta/M\nLaurette/M\nLauri/M\nLaurianne/M\nLaurice/M\nLaurie/M\nLauritz/M\nLauryn/M\nLausanne/M\nLaval/M\nLavena/M\nLavern/M\nLaverna/M\nLaverne/M\nLavina/M\nLavinia/M\nLavinie/M\nLavoisier/M\nLavonne/M\nLaw/M\nLawanda/M\nLawford/M\nLawrence/M\nLawrenceville/M\nLawry/M\nLawson/M\nLawton/M\nLay/M\nLayamon/M\nLayla/M\nLayne/M\nLayney/M\nLayton/M\nLazar/M\nLazare/M\nLazaro/M\nLazarus/M\nLe/NM\nLea/M\nLeach/M\nLeadbelly/M\nLeah/M\nLeakey/M\nLean/M\nLeander/M\nLeandra/M\nLeann/M\nLeanna/M\nLeanne/M\nLeanor/M\nLeanora/M\nLear/M\nLeary/M\nLeavenworth/M\nLebanese\nLebanon/M\nLebbie/M\nLebesgue/M\nLeblanc/M\nLeda/M\nLederberg/M\nLee/M\nLeeann/M\nLeeanne/M\nLeeds/M\nLeela/M\nLeelah/M\nLeeland/M\nLeena/M\nLeesa/M\nLeese/M\nLeeuwenhoek/M\nLeeward/M\nLeft/S\nLefty/M\nLegendre/M\nLeger/SM\nLeghorn/SM\nLego/M\nLegra/M\nLegree/M\nLehigh/M\nLehman/M\nLeia/M\nLeibniz/M\nLeicester/SM\nLeiden/M\nLeif/M\nLeigh/M\nLeigha/M\nLeighton/M\nLeila/M\nLeilah/M\nLeipzig/M\nLeisha/M\nLek/M\nLela/M\nLelah/M\nLeland/M\nLelia/M\nLem/M\nLemaitre/M\nLemar/M\nLemke/M\nLemmie/M\nLemmy/M\nLemuel/M\nLemuria/M\nLen/M\nLena/M\nLenard/M\nLenci/M\nLenee/M\nLenette/M\nLenin/M\nLeningrad/M\nLeninism/M\nLeninist\nLenka/M\nLenna/M\nLennard/M\nLennie/M\nLennon/M\nLenny/M\nLeno/M\nLenoir/M\nLenora/M\nLenore/M\nLent/SMN\nLeo/MS\nLeodora/M\nLeoine/M\nLeola/M\nLeoline/M\nLeon/M\nLeona/M\nLeonanie/M\nLeonard/M\nLeonardo/M\nLeoncavallo/M\nLeone/M\nLeonel/M\nLeonelle/M\nLeonerd/M\nLeonhard/M\nLeonid/M\nLeonidas/M\nLeonie/M\nLeonor/M\nLeonora/M\nLeonore/M\nLeontine/M\nLeontyne/M\nLeopold/M\nLeopoldo/M\nLeopoldville/M\nLeora/M\nLepidus/M\nLepke/M\nLepus/M\nLerner/M\nLeroi/M\nLeroy/M\nLes/Y\nLesa/M\nLeshia/M\nLesley/M\nLesli/M\nLeslie/M\nLesly/M\nLesotho/M\nLesseps/M\nLessie/M\nLester/M\nLesya/M\nLeta/M\nLetha/M\nLethe/M\nLethia/M\nLeticia/M\nLetisha/M\nLetitia/M\nLetizia/M\nLetta/M\nLetterman/M\nLetti/M\nLettie/M\nLetty/M\nLeupold/M\nLev/M\nLevant/M\nLevesque/M\nLevey/M\nLevi/MS\nLeviathan\nLevin/M\nLevine/M\nLeviticus/M\nLevitt/M\nLevon/M\nLevy/M\nLew/M\nLewellyn/M\nLewes\nLewie/M\nLewinsky/M\nLewis/M\nLewiss\nLexi/MS\nLexie/M\nLexine/M\nLexington/M\nLexus/M\nLexy/M\nLeyden/M\nLeyla/M\nLezley/M\nLezlie/M\nLhasa/SM\nLhotse/M\nLi/MY\nLia/M\nLiam/M\nLian/M\nLiana/M\nLiane/M\nLianna/M\nLianne/M\nLib/M\nLibbey/M\nLibbi/M\nLibbie/M\nLibby/M\nLiberace/M\nLiberia/M\nLiberian/S\nLibra/SM\nLibreville/M\nLibrium/M\nLibya/M\nLibyan/S\nLicha/M\nLichtenstein/M\nLichter/M\nLida/M\nLidia/M\nLie/M\nLieberman/M\nLiebfraumilch/M\nLiechtenstein/RMZ\nLief/M\nLiege/M\nLiesa/M\nLieut/M\nLil/MY\nLila/SM\nLilah/M\nLilia/MS\nLilian/M\nLiliana/M\nLiliane/M\nLilith/M\nLiliuokalani/M\nLilla/M\nLille/M\nLilli/MS\nLillian/M\nLillie/M\nLilliput/M\nLilliputian/SM\nLilllie/M\nLilly/M\nLilongwe/M\nLily/M\nLilyan/M\nLima/M\nLimbaugh/M\nLimbo\nLimburger/SM\nLimoges/M\nLimpopo/M\nLin/M\nLina/M\nLinc/M\nLincoln/SM\nLind/M\nLinda/M\nLindberg/M\nLindbergh/M\nLindholm/M\nLindi/M\nLindie/M\nLindon/M\nLindquist/M\nLindsay/M\nLindsey/M\nLindstrom/M\nLindsy/M\nLindy/M\nLinea/M\nLinell/M\nLinet/M\nLinette/M\nLink/M\nLinn/M\nLinnaeus/M\nLinnea/M\nLinnell/M\nLinnet/M\nLinnie/M\nLinoel/M\nLinotype/M\nLinton/M\nLinus/M\nLinux/M\nLinwood/M\nLinzy/M\nLion/M\nLionel/M\nLionello/M\nLippi/M\nLippmann/M\nLipschitz/M\nLipscomb/M\nLipton/M\nLira/M\nLisa/M\nLisabeth/M\nLisbeth/M\nLisbon/M\nLise/M\nLisetta/M\nLisette/M\nLisha/M\nLishe/M\nLisle/M\nLiss/M\nLissa/M\nLissajous/M\nLissi/M\nLissie/M\nLissy/M\nLister/M\nListerine/M\nListon/M\nLiszt/M\nLita/M\nLithuania/M\nLithuanian/S\nLittle/M\nLittleton/M\nLitton/M\nLiuka/M\nLiv/M\nLiva/M\nLivermore/M\nLiverpool/M\nLiverpudlian/MS\nLivia/M\nLivingston/M\nLivingstone/M\nLivonia/M\nLivvie/M\nLivvy/M\nLivvyy/M\nLivy/M\nLiz/M\nLiza/M\nLizabeth/M\nLizbeth/M\nLizette/M\nLizzie/M\nLizzy/M\nLjubljana/M\nLlewellyn/M\nLloyd/M\nLlywellyn/M\nLoafer/S\nLobachevsky/M\nLochinvar/M\nLock/M\nLocke/M\nLockean/M\nLockhart/M\nLockheed/M\nLockian/M\nLockwood/M\nLodge/M\nLodovico/M\nLodowick/M\nLodz\nLoeb/M\nLoella/M\nLoewe/M\nLoewi/M\nLogan/M\nLohengrin/M\nLoire/M\nLois/M\nLoise/M\nLoki/M\nLola/M\nLoleta/M\nLolita/M\nLolly/M\nLomb/M\nLombard/M\nLombardi/M\nLombardy/M\nLome\nLon/M\nLona/M\nLondon/RMZ\nLondonderry/M\nLondoner/M\nLonee/M\nLong/M\nLongfellow/M\nLongstreet/M\nLongueuil/M\nLoni/M\nLonna/M\nLonnard/M\nLonni/M\nLonnie/M\nLonny/M\nLoomis/M\nLopez/M\nLora/M\nLorain/M\nLoraine/M\nLoralee/M\nLoralie/M\nLoralyn/M\nLorant/M\nLord/MS\nLordship/SM\nLoree/M\nLoreen/M\nLorelei/M\nLorelle/M\nLoren/SM\nLorena/M\nLorene/M\nLorentz/M\nLorentzian/M\nLorenz/M\nLorenza/M\nLorenzo/M\nLoretta/M\nLorette/M\nLori/M\nLoria/M\nLorianna/M\nLorianne/M\nLorie/M\nLorilee/M\nLorilyn/M\nLorin/M\nLorinda/M\nLorine/M\nLorita/M\nLorna/M\nLorne/M\nLorraine/M\nLorrayne/M\nLorre/M\nLorri/M\nLorrie/M\nLorrin/M\nLorry/M\nLory/M\nLos\nLot/M\nLothaire/M\nLothario/MS\nLott/M\nLotta/M\nLotte/M\nLotti/M\nLottie/M\nLotty/M\nLou/M\nLouella/M\nLouie/M\nLouis/M\nLouisa/M\nLouise/M\nLouisette/M\nLouisiana/M\nLouisianan/S\nLouisianian/S\nLouisville/M\nLourdes/M\nLoutitia/M\nLouvre/M\nLove/M\nLovecraft/M\nLovejoy/M\nLovelace/M\nLoveland/M\nLovell/M\nLowe/M\nLowell/M\nLowery/M\nLowlands/M\nLowrance/M\nLoy/M\nLoyang/M\nLoyd/M\nLoydie/M\nLoyola/M\nLr\nLt/M\nLtd/M\nLu/M\nLuanda/M\nLuann/M\nLubbock/M\nLubumbashi/M\nLuca/MS\nLucais/M\nLuce/M\nLucerne/M\nLucho/M\nLuci/MN\nLucia/MS\nLucian/M\nLuciana/M\nLuciano/M\nLucie/M\nLucien/M\nLucienne/M\nLucifer/M\nLucila/M\nLucile/M\nLucilia/M\nLucille/M\nLucina/M\nLucinda/M\nLucine/M\nLucio/M\nLucita/M\nLucite/MS\nLucius/M\nLucknow/M\nLucky/M\nLucretia/M\nLucretius/M\nLucy/M\nLuddite/SM\nLudhiana/M\nLudlow/M\nLudmilla/M\nLudovico/M\nLudovika/M\nLudvig/M\nLudwig/M\nLuella/M\nLuelle/M\nLufthansa/M\nLuftwaffe/M\nLuger/M\nLugosi/M\nLuigi/M\nLuis/M\nLuisa/M\nLuise/M\nLukas/M\nLuke/M\nLula/M\nLulita/M\nLulu/M\nLumire/M\nLuna/M\nLund/M\nLundberg/M\nLundquist/M\nLupe/M\nLupus/M\nLura/M\nLurette/M\nLuria/M\nLurleen/M\nLurlene/M\nLurline/M\nLusa/M\nLusaka/M\nLusitania/M\nLutero/M\nLuther/M\nLutheran/SM\nLutheranism/MS\nLutz\nLuxembourg/RMZ\nLuxembourgian\nLuxemburg's\nLuz/M\nLuzon/M\nLy/MY\nLyX/M\nLyallpur/M\nLycra/S\nLycurgus/M\nLyda/M\nLydia/M\nLydian/S\nLydie/M\nLydon/M\nLyell/M\nLyle/M\nLyly/M\nLyman/M\nLyme/M\nLyn/M\nLynch/M\nLynchburg/M\nLynda/M\nLynde/M\nLyndel/M\nLyndell/M\nLyndon/M\nLyndsay/M\nLyndsey/M\nLyndsie/M\nLyndy/M\nLynea/M\nLynelle/M\nLynett/M\nLynette/M\nLynn/M\nLynna/M\nLynne/M\nLynnea/M\nLynnell/M\nLynnelle/M\nLynnet/M\nLynnett/M\nLynnette/M\nLynsey/M\nLyon/SM\nLyra/M\nLysenko/M\nLysistrata/M\nLysol/M\nLyssa/M\nM's\nM/GB\nMA\nMAG\nMASH\nMB\nMBA\nMC\nMCI/M\nMD\nMDT\nME\nMFA\nMGM/M\nMHz\nMI\nMIA\nMIG/S\nMIMD\nMIPS\nMIRV/DSG\nMIT/M\nMITRE/SM\nMM\nMMe\nMN\nMO\nMP\nMPH\nMRI\nMS\nMSG\nMST\nMSW\nMT\nMTS\nMTV\nMULTICS/M\nMVP\nMW\nMaalox/M\nMab/M\nMabel/M\nMabelle/M\nMable/M\nMac/SGMD\nMacArthur/M\nMacDonald/M\nMacDraw/M\nMacGregor/M\nMacIntosh/M\nMacKenzie/M\nMacLeish/M\nMacMillan/M\nMacPaint/M\nMacao/M\nMacarthur/M\nMacaulay/M\nMacbeth/M\nMaccabees/M\nMaccabeus/M\nMacdonald/M\nMace/MS\nMacedon/M\nMacedonia/M\nMacedonian/S\nMacgregor/M\nMach/M\nMachiavelli/M\nMachiavellian/S\nMachs\nMacias/M\nMacintosh/M\nMack/M\nMackenzie/M\nMackinac/M\nMackinaw\nMacmillan/M\nMacon/SM\nMacy/M\nMada/M\nMadagascan/SM\nMadagascar/M\nMadalena/M\nMadalyn/M\nMadame/MS\nMaddalena/M\nMadden/M\nMaddi/M\nMaddie/M\nMaddox/M\nMaddy/M\nMadeira/SM\nMadel/M\nMadelaine/M\nMadeleine/M\nMadelena/M\nMadelene/M\nMadelin/M\nMadelina/M\nMadeline/M\nMadella/M\nMadelle/M\nMadelon/M\nMadelyn/M\nMadge/M\nMadhya/M\nMadison/M\nMadlen/M\nMadlin/M\nMadonna/MS\nMadras\nMadrid/M\nMadsen/M\nMadurai/M\nMady/M\nMae/M\nMaegan/M\nMaelstrom/M\nMaeterlinck/M\nMafia/MS\nMafioso/S\nMag/M\nMagda/M\nMagdaia/M\nMagdalen/M\nMagdalena/M\nMagdalene/M\nMagellan/M\nMagellanic\nMaggee/M\nMaggi/M\nMaggie/M\nMaggy/M\nMagi/M\nMagill/M\nMaginot/M\nMagnitogorsk/M\nMagnum\nMagnuson/M\nMagog/M\nMagoo/M\nMagritte/M\nMagruder/M\nMagsaysay/M\nMaguire/SM\nMagus/M\nMagyar/MS\nMahabharata\nMahala/M\nMahalia/M\nMaharashtra/M\nMahavira/M\nMahayana/M\nMahayanist\nMahdi/M\nMahfouz/M\nMahican/SM\nMahler/M\nMahmoud/M\nMahmud/M\nMahomet's\nMai/MR\nMaia/M\nMaible/M\nMaier/M\nMaiga/M\nMaighdiln/M\nMaigret/M\nMailer/M\nMaillol/M\nMaiman/M\nMaimonides/M\nMaine/MZR\nMainer/M\nMair/M\nMaire/M\nMaisey/M\nMaisie/M\nMaison/M\nMaitilde/M\nMaj\nMaje/M\nMajesty/MS\nMajor/M\nMajorca/M\nMajuro/M\nMakarios/M\nMaker/M\nMal/M\nMala/M\nMalabar/M\nMalabo/M\nMalacca/M\nMalachi/M\nMalagasy/M\nMalamud/M\nMalanie/M\nMalaprop/M\nMalawi/M\nMalawian/S\nMalay/SM\nMalaya/M\nMalayalam/M\nMalayan/MS\nMalaysia/M\nMalaysian/S\nMalchy/M\nMalcolm/M\nMaldive/SM\nMaldivian/S\nMaldonado/M\nMale/M\nMalena/M\nMali/M\nMalia/M\nMalian/S\nMalibu/M\nMalina/M\nMalinda/M\nMalinde/M\nMalinowski/M\nMalissa/M\nMalissia/M\nMallarm/M\nMallissa/M\nMallorie/M\nMallory/M\nMalone/M\nMalorie/M\nMalory/M\nMalraux/M\nMalta/M\nMaltese\nMalthus/M\nMalthusian/S\nMalva/M\nMalvin/M\nMalvina/M\nMalynda/M\nMame/M\nMamet/M\nMamie/M\nMammon's\nMamore/M\nMan/SM\nManagua/M\nManama/M\nManasseh/M\nManaus's\nManchester/M\nManchu/MS\nManchuria/M\nManchurian/S\nMancini/M\nMancunian/MS\nManda/M\nMandalay/M\nMandarin\nMandel/M\nMandela\nMandelbrot/M\nMandi/M\nMandie/M\nMandingo/M\nMandy/M\nManet/M\nManfred/M\nManhattan/SM\nMani/M\nManichean/M\nManila/MS\nManitoba/M\nManitoulin/M\nManitowoc/M\nMankowski/M\nManley/M\nMann/GM\nMannheim/M\nMannie/M\nManning/M\nManny/M\nMano/M\nManolo/M\nManon/M\nMansfield/M\nManson/M\nMantegna/M\nMantle/M\nManuel/M\nManuela/M\nManville/M\nManx\nManya/M\nMao/M\nMaoism/MS\nMaoist/S\nMaori/SM\nMaplecrest/M\nMapplethorpe/M\nMaputo/M\nMar/SMN\nMara/M\nMarabel/M\nMaracaibo/M\nMarat/M\nMarathi\nMarathon/M\nMarc/M\nMarceau/M\nMarcel/M\nMarcela/M\nMarcelia/M\nMarcelino/M\nMarcella/M\nMarcelle/M\nMarcellina/M\nMarcelline/M\nMarcello/M\nMarcellus/M\nMarcelo/M\nMarch/MS\nMarchall/M\nMarchelle/M\nMarci/M\nMarcia/M\nMarciano/M\nMarcie/M\nMarcile/M\nMarcille/M\nMarco/SM\nMarconi/M\nMarcotte/M\nMarcus/M\nMarcy/M\nMardi/SM\nMarduk/M\nMareah/M\nMaren/M\nMarena/M\nMaressa/M\nMarga/M\nMargalit/M\nMargalo/M\nMargaret/M\nMargareta/M\nMargarete/M\nMargaretha/M\nMargarethe/M\nMargaretta/M\nMargarette/M\nMargarita/M\nMargarito/M\nMargaux/M\nMarge/M\nMargeaux/M\nMargery/M\nMarget/M\nMargette/M\nMargi/M\nMargie/M\nMargit/M\nMargo/M\nMargot/M\nMargret/M\nMargrethe/M\nMarguerite/M\nMargy/M\nMari/MS\nMaria/M\nMariam/M\nMarian/MS\nMariana/SM\nMariann/M\nMarianna/M\nMarianne/M\nMariano/M\nMaribel/M\nMaribelle/M\nMaribeth/M\nMarice/M\nMaricela/M\nMaridel/M\nMarie/M\nMarieann/M\nMariejeanne/M\nMariel/M\nMariele/M\nMarielle/M\nMariellen/M\nMarietta/M\nMariette/M\nMarigold/M\nMarijn/M\nMarijo/M\nMarika/M\nMarilee/M\nMarilin/M\nMarillin/M\nMarilyn/M\nMarin/M\nMarina/M\nMarine/S\nMarinna/M\nMarino/M\nMario/M\nMarion/M\nMariquilla/M\nMarisa/M\nMariska/M\nMarisol/M\nMarissa/M\nMarita/M\nMaritain/M\nMaritsa/M\nMaritza/M\nMariupol/M\nMarius/M\nMariya/M\nMarj/M\nMarja/M\nMarje/M\nMarji/M\nMarjie/M\nMarjorie/M\nMarjory/M\nMarjy/M\nMark/MS\nMarkab/M\nMarketa/M\nMarkham/M\nMarkism/M\nMarkos\nMarkov\nMarkovian\nMarkovitz/M\nMarkus/M\nMarla/M\nMarlane/M\nMarlboro/M\nMarlborough/M\nMarleah/M\nMarlee/M\nMarleen/M\nMarlena/M\nMarlene/M\nMarley/M\nMarlie/M\nMarlin/M\nMarline/M\nMarlo/M\nMarlon/M\nMarlow/M\nMarlowe/M\nMarlyn/M\nMarmaduke/M\nMarmara/M\nMarna/M\nMarne/M\nMarney/M\nMarni/M\nMarnia/M\nMarnie/M\nMarquesas/M\nMarquette/M\nMarquez/M\nMarquis/M\nMarquita/M\nMarrakesh/M\nMarrilee/M\nMarriott/M\nMarris/M\nMarrissa/M\nMarseillaise/SM\nMarseille's\nMarseilles\nMarsh/M\nMarsha/M\nMarshal/M\nMarshall/GDM\nMarshalled/M\nMarshalling/M\nMarsiella/M\nMart/MN\nMarta/M\nMartainn/M\nMartel/M\nMartelle/M\nMarten/M\nMartguerita/M\nMartha/M\nMarthe/M\nMarthena/M\nMarti/M\nMartial\nMartian/S\nMartica/M\nMartie/M\nMartin/M\nMartina/M\nMartinez/M\nMartinique/M\nMartino/M\nMartinson/M\nMartita/M\nMarty/M\nMartyn/M\nMartynne/M\nMarv/NM\nMarva/M\nMarve/M\nMarvell/M\nMarven/M\nMarvin/M\nMarwin/M\nMarx/M\nMarxian/S\nMarxism/SM\nMarxist/SM\nMary/M\nMarya/M\nMaryann/M\nMaryanna/M\nMaryanne/M\nMarybelle/M\nMarybeth/M\nMaryellen/M\nMaryjane/M\nMaryjo/M\nMaryl/M\nMaryland/MZR\nMarylee/M\nMarylin/M\nMarylinda/M\nMarylou/M\nMarylynne/M\nMaryrose/M\nMarys\nMarysa/M\nMasada/M\nMasai/M\nMasaryk/M\nMascagni/M\nMasefield/M\nMaseru/M\nMasha/M\nMashhad/M\nMason/SM\nMasonic\nMasonite/M\nMass/S\nMassachusetts/M\nMassasoit/M\nMassenet/M\nMassey/M\nMassimiliano/M\nMassimo/M\nMaster/SM\nMata/M\nMatelda/M\nMateo/M\nMathe/RM\nMathematica/M\nMathematik/M\nMather/M\nMathew/MS\nMathewson/M\nMathian/M\nMathias\nMathieu/M\nMathilda/M\nMathilde/M\nMathis\nMatias/M\nMatilda/M\nMatilde/M\nMatisse/SM\nMatsumoto/M\nMatt/M\nMattel/M\nMatteo/M\nMatterhorn/M\nMatthaeus/M\nMattheus/M\nMatthew/MS\nMatthias\nMatthieu/M\nMatthiew/M\nMatthus/M\nMatti/M\nMattias/M\nMattie/M\nMatty/M\nMaud/M\nMaude/M\nMaudie/M\nMaugham/M\nMaui/M\nMaupassant/M\nMaura/M\nMaure/M\nMaureen/M\nMaureene/M\nMaurene/M\nMauriac/M\nMaurice/M\nMauricio/M\nMaurie/M\nMaurine/M\nMaurise/M\nMaurita/M\nMauritania/M\nMauritanian/S\nMauritian/S\nMauritius/M\nMaurits/M\nMaurizia/M\nMaurizio/M\nMauro/M\nMaurois/M\nMaury/M\nMauser/M\nMavis/M\nMavra/M\nMawr/M\nMax/M\nMaxi/M\nMaxie/M\nMaxim/M\nMaximilian/M\nMaximilianus/M\nMaximilien/M\nMaximo/M\nMaxine/M\nMaxtor/M\nMaxwell/M\nMaxwellian\nMaxy/M\nMay/SMR\nMaya/MS\nMayan/S\nMaybelle/M\nMaye/M\nMayer/M\nMayfair/M\nMayflower/M\nMaynard/M\nMayne/M\nMaynord/M\nMayo/M\nMayor/M\nMaypole/SM\nMayra/M\nMazama/M\nMazarin/M\nMazatlan/M\nMazda/M\nMazzini/M\nMb\nMbabane/M\nMbini/M\nMcAdam/MS\nMcAllister/M\nMcBride/M\nMcCabe/M\nMcCain/M\nMcCall/M\nMcCarthy/M\nMcCarthyism/M\nMcCartney/M\nMcCarty/M\nMcCauley/M\nMcClain/M\nMcClellan/M\nMcClure/M\nMcCluskey/M\nMcConnell/M\nMcCormick/M\nMcCoy/SM\nMcCracken/M\nMcCray/M\nMcCullough/M\nMcDaniel/M\nMcDermott/M\nMcDonald/M\nMcDonnell/M\nMcDougall/M\nMcDowell/M\nMcElhaney/M\nMcEnroe/M\nMcFadden/M\nMcFarland/M\nMcGee/M\nMcGill/M\nMcGovern/M\nMcGowan/M\nMcGrath/M\nMcGraw/M\nMcGregor/M\nMcGuffey/M\nMcGuire/M\nMcIntosh/M\nMcIntyre/M\nMcKay/M\nMcKee/M\nMcKenzie/M\nMcKesson/M\nMcKinley/M\nMcKinney/M\nMcKnight/M\nMcLanahan/M\nMcLaughlin/M\nMcLean/M\nMcLeod/M\nMcLuhan/M\nMcMahon/M\nMcMartin/M\nMcMillan/M\nMcNamara/M\nMcNaughton/M\nMcNeil/M\nMcPherson/M\nMd/M\nMe/M\nMead/M\nMeade/M\nMeadows\nMeagan/M\nMeaghan/M\nMeany/M\nMeara/M\nMecca/MS\nMechelle/M\nMedan/M\nMedea/M\nMedellin\nMedfield/M\nMedicaid/SM\nMedicare/MS\nMedici/MS\nMedina/M\nMediterranean/MS\nMedusa/M\nMeg/MN\nMegan/M\nMegen/M\nMeggi/M\nMeggie/M\nMeggy/M\nMeghan/M\nMeghann/M\nMehetabel/M\nMei/MR\nMeier/M\nMeighen/M\nMeiji/M\nMeir/M\nMeister/M\nMeistersinger/M\nMejia/M\nMekong/M\nMel/MY\nMela/M\nMelamie/M\nMelanesia/M\nMelanesian/S\nMelania/M\nMelanie/M\nMelantha/M\nMelany/M\nMelba/M\nMelbourne/M\nMelcher/M\nMelchior/M\nMelendez/M\nMelesa/M\nMelessa/M\nMelicent/M\nMelina/M\nMelinda/M\nMelinde/M\nMelisa/M\nMelisande/M\nMelisandra/M\nMelisenda/M\nMelisent/M\nMelissa/M\nMelisse/M\nMelita/M\nMelitta/M\nMella/M\nMelli/M\nMellicent/M\nMellie/M\nMellisa/M\nMellisent/M\nMellon/M\nMelloney/M\nMelly/M\nMelodee/M\nMelodie/M\nMelody/M\nMelonie/M\nMelony/M\nMelosa/M\nMelpomene/M\nMelton/M\nMelva/M\nMelville/M\nMelvin/M\nMelvyn/M\nMemling/M\nMemphis/M\nMenander/M\nMenard/M\nMencius/M\nMencken/M\nMendel/M\nMendeleev/M\nMendelian\nMendelssohn/M\nMendez/M\nMendie/M\nMendocino/M\nMendoza/M\nMendy/M\nMenelaus/M\nMenes/M\nMenkalinan/M\nMenkar/M\nMenkent/M\nMenlo/M\nMennonite/SM\nMenominee\nMenotti/M\nMensa/M\nMensch/M\nMenuhin/M\nMenzies/M\nMephistopheles/M\nMerak/M\nMercado/M\nMercator/M\nMercedes\nMercer/M\nMerci/M\nMercie/M\nMerck/M\nMercurochrome/M\nMercury/MS\nMercy/M\nMeredeth/M\nMeredith/M\nMeredithe/M\nMerell/M\nMeridel/M\nMeridith/M\nMeriel/M\nMerilee/M\nMerill/M\nMerilyn/M\nMeris\nMerissa/M\nMeriwether/M\nMerl/M\nMerla/M\nMerle/M\nMerlin/M\nMerlina/M\nMerline/M\nMerna/M\nMerola/M\nMerralee/M\nMerrel/M\nMerriam/M\nMerrick/M\nMerridie/M\nMerrie/M\nMerrielle/M\nMerrile/M\nMerrilee/M\nMerrili/M\nMerrill/M\nMerrily/M\nMerrimac/M\nMerrimack/M\nMerritt/M\nMerry/M\nMersey/M\nMerton/M\nMerv/M\nMervin/M\nMerwin/M\nMerwyn/M\nMeryl/M\nMesa\nMesabi/M\nMeshed's\nMesolithic/M\nMesopotamia/M\nMesopotamian/S\nMesozoic\nMesserschmidt/M\nMessiaen/M\nMessiah/M\nMessiahs\nMessianic\nMessrs/M\nMeta/M\nMethodism/SM\nMethodist/MS\nMethuen/M\nMethuselah/M\nMethuselahs\nMetrecal/M\nMetternich/M\nMetzler/M\nMeuse/M\nMex\nMexicali/M\nMexican/S\nMexico/M\nMeyer/SM\nMeyerbeer/M\nMg/M\nMgr\nMia/M\nMiami/SM\nMiaplacidus/M\nMic/M\nMicaela/M\nMicah/M\nMich/M\nMichael/SM\nMichaela/M\nMichaelangelo/M\nMichaelina/M\nMichaeline/M\nMichaella/M\nMichaelmas/MS\nMichaelson/M\nMichail/M\nMichal/M\nMichale/M\nMicheal/M\nMicheil/M\nMichel/M\nMichelangelo/M\nMichele/M\nMichelin/M\nMichelina/M\nMicheline/M\nMichell/M\nMichelle/M\nMichelson/M\nMichigan/M\nMichigander/S\nMichiganite/S\nMick/M\nMickelson/M\nMickey/M\nMicki/M\nMickie/M\nMicky/M\nMicmac/M\nMicroVAX/M\nMicroVAXes\nMicronesia/M\nMicronesian/S\nMicroport/M\nMicrosoft/M\nMicrosystems\nMidas/M\nMiddlebury/M\nMiddlesex/M\nMiddleton/M\nMiddletown/M\nMideast/M\nMideastern\nMidge/M\nMidland/MS\nMidway/M\nMidwest/M\nMidwestern/ZR\nMidwesterner/M\nMignon/M\nMignonne/M\nMiguel/M\nMiguela/M\nMiguelita/M\nMikael/M\nMikaela/M\nMike/M\nMikel/M\nMikey/M\nMikhail/M\nMikkel/M\nMikol/M\nMikoyan/M\nMil/MY\nMilagros/M\nMilan/M\nMilanese\nMildred/M\nMildrid/M\nMile/SM\nMilena/M\nMilford/M\nMilicent/M\nMilissent/M\nMilka/M\nMilken/M\nMill/SMR\nMillard/M\nMillay/M\nMiller/M\nMillet/M\nMilli/M\nMillicent/M\nMillie/M\nMillikan/M\nMillisent/M\nMilly/M\nMilne/M\nMilo/M\nMilquetoast/S\nMilt/M\nMiltiades/M\nMiltie/M\nMilton/M\nMiltonic\nMiltown/M\nMilty/M\nMilwaukee/M\nMilzie/M\nMimi/M\nMimosa/M\nMin/MR\nMina/M\nMinda/M\nMindanao/M\nMindoro/M\nMindy/M\nMiner/M\nMinerva/M\nMinetta/M\nMinette/M\nMing/M\nMingus/M\nMinn/M\nMinna/M\nMinnaminnie/M\nMinne/M\nMinneapolis/M\nMinnesota/M\nMinnesotan/S\nMinni/M\nMinnie/M\nMinnnie/M\nMinny/M\nMinoan/S\nMinolta/M\nMinor/M\nMinos\nMinot/M\nMinotaur/M\nMinsk/M\nMinsky/M\nMinta/M\nMintaka/M\nMinuit/M\nMinuteman/M\nMiocene\nMiquela/M\nMir/M\nMira/M\nMirabeau/M\nMirabel/M\nMirabella/M\nMirabelle/M\nMirach/M\nMiran/M\nMiranda/M\nMireielle/M\nMireille/M\nMirella/M\nMirelle/M\nMirfak/M\nMiriam/M\nMirilla/M\nMirna/M\nMiro\nMirzam/M\nMischa/M\nMisha/M\nMiskito\nMiss/SM\nMissie/M\nMississauga/M\nMississippi/M\nMississippian/S\nMissoula/M\nMissouri/M\nMissourian/S\nMissy/M\nMistassini/M\nMister/SM\nMisti/M\nMistress/MS\nMisty/M\nMitch/M\nMitchael/M\nMitchel/M\nMitchell/M\nMitford/M\nMithra/M\nMithridates/M\nMitsubishi/M\nMitterrand/M\nMitty/M\nMitzi/M\nMizar/M\nMk\nMlle/M\nMme/SM\nMn/M\nMnemosyne/M\nMo/MN\nMobil/M\nMobile/M\nMobutu/M\nModesta/M\nModestia/M\nModestine/M\nModesto/M\nModesty/M\nModigliani/M\nModula/M\nMoe/M\nMoen/M\nMogadiscio's\nMogadishu\nMogul/MS\nMohamed/M\nMohammad/M\nMohammed's\nMohammedan/SM\nMohammedanism/MS\nMohandas/M\nMohandis/M\nMohawk/MS\nMohegan/S\nMohican's\nMoho/M\nMohorovicic/M\nMohr/M\nMoina/M\nMoines/M\nMoira/M\nMoise/MS\nMoiseyev/M\nMoishe/M\nMojave/M\nMoldavia/M\nMoldavian/S\nMoldova\nMoliere\nMolina/M\nMoline/M\nMoll/M\nMollee/M\nMolli/M\nMollie/M\nMolly/M\nMolnar/M\nMoloch/M\nMolokai/M\nMolotov/M\nMoluccas\nMombasa/M\nMommy/M\nMon/SM\nMona/M\nMonaco/M\nMonah/M\nMonash/M\nMondale/M\nMonday/MS\nMondrian/M\nMonegasque/SM\nMonera/M\nMonet/M\nMonfort/M\nMongol/SM\nMongolia/M\nMongolian/S\nMongolic/M\nMongoloid/S\nMonica/M\nMonika/M\nMonique/M\nMonk/M\nMonmouth/M\nMonongahela/M\nMonro/M\nMonroe/M\nMonrovia/M\nMonsanto/M\nMonsignor/MS\nMonsignori\nMont/M\nMontague/M\nMontaigne/M\nMontana/M\nMontanan/MS\nMontcalm/M\nMontclair/M\nMonte/M\nMontenegrin\nMontenegro/M\nMonterey/M\nMonterrey/M\nMontesquieu/M\nMontessori/M\nMonteverdi/M\nMontevideo/M\nMontezuma\nMontgomery/M\nMonti/M\nMonticello/M\nMontmartre/M\nMontoya/M\nMontpelier/M\nMontrachet/M\nMontreal/M\nMontserrat/M\nMonty/M\nMoody/M\nMoog\nMoon/M\nMooney/M\nMoor/MS\nMoore/M\nMoorish\nMora/M\nMorales/M\nMoran/M\nMoravia/M\nMoravian\nMord/M\nMordecai/M\nMordred/M\nMordy/M\nMore/M\nMoreen/M\nMorehouse/M\nMoreland/M\nMorena/M\nMoreno/M\nMorey/M\nMorgan/MS\nMorgana/M\nMorganica/M\nMorganne/M\nMorgen/M\nMorgun/M\nMoria/M\nMoriarty/M\nMorie/M\nMorin/M\nMorison/M\nMorissa/M\nMorita/M\nMoritz/M\nMorlee/M\nMorley/M\nMorly/M\nMormon/SM\nMormonism/MS\nMorna/M\nMoro/M\nMoroccan/S\nMorocco/M\nMoroni/M\nMorpheus/M\nMorrie/M\nMorris/M\nMorrison/M\nMorristown/M\nMorrow/M\nMorry/M\nMorse/M\nMort/MN\nMorten/M\nMortie/M\nMortimer/M\nMorton/M\nMorty/M\nMosaic\nMoscone/M\nMoscow/M\nMose/MSR\nMoseley/M\nMoselle/M\nMoser/M\nMoshe/M\nMoslem's\nMosley/M\nMoss/M\nMossberg/M\nMosul/M\nMotorola/M\nMotown/M\nMott/M\nMount/M\nMountbatten/M\nMountie/SM\nMoussorgsky/M\nMouthe/M\nMouton/M\nMowgli/M\nMoyer/M\nMoyna/M\nMoyra/M\nMozambican/S\nMozambique/M\nMozart/M\nMozelle/M\nMozes/M\nMozilla/M\nMr/M\nMrs\nMs/S\nMsgr/M\nMt/M\nMuawiya/M\nMubarak/M\nMueller/M\nMuenster\nMuffin/M\nMufi/M\nMufinella/M\nMugabe/M\nMuhammad/M\nMuhammadan/SM\nMuhammadanism/S\nMuir/M\nMuire/M\nMukden/M\nMulder/M\nMullen/M\nMuller/M\nMulligan/M\nMullikan/M\nMullins\nMultan/M\nMultibus/M\nMultics/M\nMumford/M\nMunch/M\nMuncie/M\nMundt/M\nMunich/M\nMunmro/M\nMunoz/M\nMunro/M\nMunroe/M\nMunsey/M\nMunson/M\nMunster/MS\nMuong/M\nMuppet/M\nMurasaki/M\nMurat/M\nMurchison/M\nMurcia/M\nMurdoch/M\nMurdock/M\nMureil/M\nMurial/M\nMuriel/M\nMurielle/M\nMurillo/M\nMurmansk/M\nMurphy/M\nMurray/M\nMurrow/M\nMurrumbidgee/M\nMurry/M\nMurvyn/M\nMuscat/M\nMuscovite/M\nMuscovy/M\nMuse/M\nMusial/M\nMuskegon/M\nMuslim/MS\nMussolini/MS\nMussorgsky/M\nMutsuhito/M\nMuzak/SM\nMuzo/M\nMy/M\nMyanmar\nMyca/M\nMycah/M\nMycenae/M\nMycenaean\nMychal/M\nMyer/MS\nMylar/S\nMyles/M\nMylo/M\nMynheer/M\nMyra/M\nMyrah/M\nMyranda/M\nMyrdal/M\nMyriam/M\nMyrilla/M\nMyrle/M\nMyrlene/M\nMyrna/M\nMyron/M\nMyrta/M\nMyrtia/M\nMyrtice/M\nMyrtie/M\nMyrtle/M\nMyrvyn/M\nMyrwyn/M\nMysore/M\nMyst/M\nMnchhausen/M\nN\nN'Djamena\nN's\nNAACP\nNASA/MS\nNASDAQ\nNATO/SM\nNB\nNBA\nNBC\nNBS\nNC\nNCAA\nNCC\nNCO\nNCR\nND\nNE\nNF\nNFC\nNFL\nNFS\nNH\nNHL\nNIH\nNIMBY\nNJ\nNLRB\nNM\nNOAA\nNORAD/M\nNOW\nNP\nNRA\nNS\nNSF\nNT\nNV\nNW\nNWT\nNY\nNYC\nNYSE\nNZ\nNa/M\nNaCl/M\nNabisco/M\nNabokov/M\nNada/M\nNadean/M\nNadeen/M\nNader/M\nNadia/M\nNadine/M\nNadiya/M\nNady/M\nNadya/M\nNagasaki/M\nNagoya/M\nNagpur/M\nNagy/M\nNahuatl/SM\nNahum/M\nNaipaul/M\nNair/M\nNairobi/M\nNaismith/M\nNakamura/M\nNakayama/M\nNakoma/M\nNalani/M\nNam/M\nNamath/M\nNamibia/M\nNamibian/S\nNan/M\nNana/M\nNanak/M\nNananne/M\nNance/M\nNancee/M\nNancey/M\nNanchang/M\nNanci/M\nNancie/M\nNancy/M\nNanete/M\nNanette/M\nNani/M\nNanice/M\nNanine/M\nNanjing\nNanking's\nNannette/M\nNanni/M\nNannie/M\nNanny/M\nNanon/M\nNanook/M\nNansen/M\nNantes/M\nNantucket/M\nNaoma/M\nNaomi/M\nNap/M\nNaphtali/M\nNapier/M\nNaples/M\nNapoleon/MS\nNapoleonic\nNappie/M\nNappy/M\nNara/M\nNarbonne/M\nNarcissus/M\nNari/M\nNariko/M\nNarmada/M\nNarragansett/M\nNash/M\nNashua/M\nNashville/M\nNassau/M\nNasser/M\nNat/M\nNata/M\nNatal/M\nNatala/M\nNatale/M\nNatalee/M\nNatalia/M\nNatalie/M\nNatalina/M\nNataline/M\nNatalya/M\nNataniel/M\nNatasha/M\nNatassia/M\nNatchez\nNate/XMN\nNathalia/M\nNathalie/M\nNathan/MS\nNathanael/M\nNathanial/M\nNathaniel/M\nNathanil/M\nNatividad/M\nNativity/M\nNatka/M\nNatty/M\nNaugahyde/S\nNaur/M\nNauru/M\nNavaho's\nNavajo/S\nNavajoes\nNavarro/M\nNavona/M\nNavratilova/M\nNavy/S\nNazarene/MS\nNazareth/M\nNazi/SM\nNazism/S\nNb/M\nNd/M\nNdjamena/M\nNe\nNeWS/M\nNeal/M\nNeala/M\nNeale/M\nNeall/M\nNealon/M\nNealson/M\nNealy/M\nNeanderthal/S\nNeapolitan/SM\nNeb/M\nNebr/M\nNebraska/M\nNebraskan/MS\nNebuchadnezzar/MS\nNed/M\nNeda/M\nNedda/M\nNeddie/M\nNeddy/M\nNedi/M\nNeedham/M\nNeel/M\nNeely/M\nNefen/M\nNefertiti/M\nNegev/M\nNegress/MS\nNegritude/S\nNegro/M\nNegroes\nNegroid/S\nNehemiah/M\nNehru/M\nNeil/SM\nNeila/M\nNeile/M\nNeill/M\nNeilla/M\nNeille/M\nNelda/M\nNelia/M\nNelie/M\nNell/M\nNelle/M\nNelli/M\nNellie/M\nNelly/M\nNels/N\nNelsen/M\nNelson/M\nNembutal/M\nNemesis/M\nNeogene\nNeolithic/M\nNepal/M\nNepalese\nNepali/MS\nNeptune/M\nNereid/M\nNerf/M\nNerissa/M\nNerita/M\nNero/M\nNeron/M\nNert/M\nNerta/M\nNerte/M\nNerti/M\nNertie/M\nNerty/M\nNeruda/M\nNessa/M\nNessi/M\nNessie/M\nNessy/M\nNesta/M\nNester/M\nNestle/M\nNestor/M\nNestorius/M\nNetherlander/SM\nNetherlands/M\nNetscape/M\nNetta/M\nNetti/M\nNettie/M\nNettle/M\nNetty/M\nNetzahualcoyotl/M\nNeumann/M\nNev/M\nNeva/M\nNevada/M\nNevadan/S\nNevadian/S\nNevil/M\nNevile/M\nNeville/M\nNevin/SM\nNevis/M\nNevsa/M\nNevsky/M\nNewark/M\nNewbury/M\nNewburyport/M\nNewcastle/M\nNewell/M\nNewfoundland/SRMZ\nNewfoundlander/M\nNewman/M\nNewport/M\nNewsweek/MY\nNewsweekly/M\nNewton/M\nNewtonian\nNexis/M\nNeysa/M\nNgaliema/M\nNguyen/M\nNi/M\nNiagara/M\nNial/M\nNiall/M\nNiamey/M\nNibelung/M\nNicaean\nNicaragua/M\nNicaraguan/S\nNiccolo/M\nNice/M\nNicene\nNichol/MS\nNicholas\nNichole/M\nNicholle/M\nNicholson/M\nNick/M\nNickey/M\nNicki/M\nNickie/M\nNicklaus/M\nNicko/M\nNickola/MS\nNickolai/M\nNickolaus/M\nNicky/M\nNico/M\nNicobar/M\nNicodemus/M\nNicol/M\nNicola/MS\nNicolai/MS\nNicole/M\nNicolea/M\nNicolette/M\nNicoli/MS\nNicolina/M\nNicoline/M\nNicolle/M\nNicosia/M\nNiebuhr/M\nNiel/MS\nNiels/N\nNielsen/M\nNielson/M\nNietzsche/M\nNieves/M\nNigel/M\nNiger/M\nNigeria/M\nNigerian/S\nNigerien\nNightingale/M\nNijinsky/M\nNikaniki/M\nNike/M\nNiki/M\nNikita/M\nNikki/M\nNikkie/M\nNikko/M\nNiko/MS\nNikola/MS\nNikolai/M\nNikolaos/M\nNikolaus/M\nNikolayev's\nNikoletta/M\nNikolia/M\nNikolos/M\nNikon/M\nNil/MS\nNile/SM\nNils/N\nNilsen/M\nNilson/M\nNilsson/M\nNimitz/M\nNimrod/MS\nNina/M\nNinetta/M\nNinette/M\nNineveh/M\nNinnetta/M\nNinnette/M\nNinon/M\nNintendo/M\nNiobe/M\nNippon/M\nNipponese\nNirenberg/M\nNirvana/S\nNisei/MS\nNissa/M\nNissan/M\nNisse/M\nNissie/M\nNissy/M\nNita/M\nNiven/M\nNixie/M\nNixon/M\nNkrumah/M\nNo/M\nNoDoz/M\nNoach/M\nNoah/M\nNoak/M\nNoam/M\nNoami/M\nNobe/M\nNobel/M\nNobelist/SM\nNobie/M\nNoble/M\nNoby/M\nNoe/M\nNoel/MS\nNoelani/M\nNoell/M\nNoella/M\nNoelle/M\nNoellyn/M\nNoelyn/M\nNoemi/M\nNola/M\nNolan/M\nNolana/M\nNoland/M\nNolie/M\nNoll/M\nNollie/M\nNolly/M\nNome/M\nNomi/M\nNona/M\nNonah/M\nNoni/M\nNonie/M\nNonna/M\nNonnah/M\nNora/M\nNorah/M\nNorbert/M\nNorberto/M\nNorbie/M\nNorby/M\nNordhoff/M\nNordic/S\nNordstrom/M\nNorean/M\nNoreen/M\nNorene/M\nNorfolk/M\nNorina/M\nNorine/M\nNorma/M\nNorman/SM\nNormand/M\nNormandy/M\nNormie/M\nNormy/M\nNorplant\nNorri/SM\nNorrie/M\nNorristown/M\nNorry/M\nNorse\nNorseman/M\nNorsemen\nNorth/M\nNorthampton/M\nNortheast/SM\nNortherner/M\nNorthfield/M\nNorthrop/M\nNorthrup/M\nNorths\nNorthumberland/M\nNorthwest/MS\nNorton/M\nNorw/M\nNorwalk/M\nNorway/M\nNorwegian/S\nNorwich/M\nNosferatu/M\nNostradamus/M\nNostrand/M\nNotre/M\nNottingham/M\nNouakchott/M\nNoumea/M\nNov/M\nNova/M\nNovak/M\nNovelia/M\nNovell/SM\nNovember/SM\nNovgorod/M\nNovocain/S\nNovocaine/M\nNovokuznetsk/M\nNovosibirsk/M\nNowell/M\nNoyce/M\nNoyes/M\nNp\nNubia/M\nNubian/M\nNugent/M\nNukualofa\nNumbers/M\nNunavut/M\nNunez/M\nNunki/M\nNuremberg/M\nNureyev/M\nNutrasweet/M\nNyasa/M\nNydia/M\nNye/M\nNyerere/M\nNyquist/M\nNyssa/M\nO\nO'Brien/M\nO'Casey\nO'Clock\nO'Connell/M\nO'Connor/M\nO'Dell/M\nO'Donnell/M\nO'Dwyer/M\nO'Er\nO'Hara\nO'Hare/M\nO'Higgins\nO'Keeffe\nO'Leary/M\nO'Neil\nO'Neill\nO'Shea/M\nO'Sullivan/M\nOAS\nOB\nOCR\nOD\nODs\nOE\nOED\nOEM/M\nOEMS\nOH\nOHSA/M\nOJ\nOK/MDG\nOKs\nON\nOOo/M\nOPEC\nOR\nOS/M\nOSHA\nOT\nOTB\nOTC\nOTOH\nOahu/M\nOakland/M\nOakley/M\nOakmont/M\nOates/M\nOaxaca/M\nOb/MD\nObadiah/M\nObadias/M\nObed/M\nObediah/M\nOberlin/M\nOberon/M\nObidiah/M\nObie/M\nOby/M\nOccam/M\nOccident/SM\nOccidental/S\nOceania/M\nOceanside/M\nOceanus/M\nOchoa/M\nOconomowoc/M\nOct/M\nOctavia/M\nOctavian/M\nOctavio/M\nOctavius/M\nOctober/MS\nOde/MR\nOdele/M\nOdelia/M\nOdelinda/M\nOdell/M\nOdella/M\nOdelle/M\nOder/M\nOderberg/MS\nOdessa/M\nOdets/M\nOdetta/M\nOdette/M\nOdey/M\nOdie/M\nOdilia/M\nOdille/M\nOdin/M\nOdis/M\nOdo/M\nOdom/M\nOdy/M\nOdysseus/M\nOdyssey/M\nOedipal/Y\nOedipus/M\nOersted/M\nOfelia/M\nOfella/M\nOffenbach/M\nOfilia/M\nOgbomosho/M\nOgdan/M\nOgden/M\nOgdon/M\nOgilvy/M\nOglethorpe/M\nOhio/M\nOhioan/S\nOise/M\nOjibwa/SM\nOkamoto/M\nOkayama/M\nOkeechobee/M\nOkefenokee\nOkhotsk/M\nOkinawa/M\nOkinawan/S\nOkla/M\nOklahoma/M\nOklahoman/SM\nOktoberfest\nOla/M\nOlaf/M\nOlag/M\nOlav/M\nOldenburg/M\nOldfield/M\nOldsmobile/M\nOlduvai/M\nOle/MV\nOleg/M\nOlen/M\nOlenek/M\nOlenka/M\nOlenolin/M\nOlga/M\nOlia/M\nOligocene\nOlimpia/M\nOlin/M\nOlive/MZR\nOliver/M\nOlivero/M\nOlivette/M\nOlivetti/M\nOlivia/M\nOlivie/RM\nOlivier/M\nOliviero/M\nOliy/M\nOllie/M\nOlly/M\nOlmec\nOlmsted/M\nOlsen/M\nOlson/M\nOlva/M\nOlvan/M\nOlwen/M\nOlympe/M\nOlympia/SM\nOlympiad/MS\nOlympian/S\nOlympic/S\nOlympie/M\nOlympus/M\nOmaha/SM\nOman/M\nOmar/M\nOmdurman/M\nOmero/M\nOmnipotent\nOmsk/M\nOnassis/M\nOndrea/M\nOneal/M\nOnega/M\nOnegin/M\nOneida/SM\nOnfre/M\nOnfroi/M\nOnida/M\nOno/M\nOnofredo/M\nOnondaga/MS\nOnsager/M\nOnt/M\nOntarian/S\nOntario/M\nOona/M\nOort/M\nOpal/M\nOpalina/M\nOpaline/M\nOpel/M\nOpenOffice.org/M\nOphelia/M\nOphelie/M\nOphiuchus/M\nOppenheimer/M\nOprah/M\nOra/M\nOralee/M\nOralia/M\nOralie/M\nOralla/M\nOralle/M\nOran/M\nOrange/M\nOranjestad/M\nOrazio/M\nOrbadiah/M\nOrdovician\nOre/NM\nOreg/M\nOregon/M\nOregonian/S\nOrel/M\nOrelee/M\nOrelia/M\nOrelie/M\nOrella/M\nOrelle/M\nOren/M\nOreo\nOrestes\nOriana/M\nOrient/SM\nOriental/S\nOrin/M\nOrinoco/M\nOrion/M\nOriya/M\nOrizaba/M\nOrkney/M\nOrlan/M\nOrland/M\nOrlando/M\nOrleans\nOrlick/M\nOrlon/SM\nOrly/M\nOrono/M\nOrpheus/M\nOrphic\nOrr/MN\nOrran/M\nOrren/M\nOrrin/M\nOrsa/M\nOrsola/M\nOrson/M\nOrtega/M\nOrtensia/M\nOrthodox/S\nOrtiz/M\nOrton/M\nOrv/M\nOrval/M\nOrville/M\nOrwell/M\nOrwellian\nOs/M\nOsage/SM\nOsaka/M\nOsbert/M\nOsborn/M\nOsborne/M\nOsbourn/M\nOsbourne/M\nOscar/SM\nOsceola/M\nOsgood/M\nOshawa/M\nOshkosh/M\nOsiris/M\nOslo/M\nOsman/M\nOsmond/M\nOsmund/M\nOssie/M\nOstrander/M\nOstrogoth/M\nOstwald/M\nOsvaldo/M\nOswald/M\nOswell/M\nOtes\nOtha/M\nOthelia/M\nOthella/M\nOthello/M\nOthilia/M\nOthilie/M\nOtho/M\nOtis/M\nOttawa/MS\nOttilie/M\nOtto/M\nOttoman\nOuagadougou/M\nOuija/MS\nOvid/M\nOwen/MS\nOxford/MS\nOxnard\nOxonian\nOxus/M\nOz/M\nOzark/SM\nOzymandias/M\nOzzie/M\nOzzy/M\nP\nP's\nPA\nPAC\nPARC/M\nPASCAL\nPBS\nPBX\nPC/M\nPCB\nPCP\nPCs\nPD\nPDP\nPDQ\nPDT\nPE\nPET\nPFC\nPG\nPIN\nPJ's\nPLO\nPM\nPMS\nPO\nPOW\nPP\nPPS\nPR\nPRC\nPRO\nPS\nPST\nPT\nPTA\nPTO\nPVC\nPW\nPX\nPa/M\nPablo/M\nPablum/M\nPabst/M\nPace/M\nPacheco/M\nPacific/M\nPackard/SM\nPackston/M\nPackwood/M\nPaco/M\nPacorro/M\nPadang/M\nPaddie/M\nPaddy/M\nPadget/M\nPadgett/M\nPadilla/M\nPadraic/M\nPadraig/M\nPadrewski/M\nPadriac/M\nPaganini/M\nPage/M\nPaglia/M\nPahlavi/M\nPaige/M\nPail/M\nPaine/M\nPakistan/M\nPakistani/S\nPalatine\nPalembang/M\nPaleocene\nPaleogene\nPaleolithic\nPaleozoic\nPalermo/M\nPalestine/M\nPalestinian/S\nPalestrina/M\nPaley/M\nPalisades/M\nPall/M\nPalladio/M\nPalm/MR\nPalmer/M\nPalmerston/M\nPalmolive/M\nPalmyra/M\nPalo/M\nPaloma/M\nPalomar/M\nPam/M\nPamela/M\nPamelina/M\nPamella/M\nPamirs\nPammi/M\nPammie/M\nPammy/M\nPampers\nPan/M\nPanama/MS\nPanamanian/S\nPanchito/M\nPancho/M\nPandora/M\nPangaea/M\nPankhurst/M\nPanmunjom/M\nPansie/M\nPansy/M\nPantagruel/M\nPantaloon/M\nPanza/M\nPaola/M\nPaoli/M\nPaolina/M\nPaolo/M\nPapagena/M\nPapageno/M\nPappas/M\nPaquito/M\nParacelsus/M\nParaclete/M\nParadise/M\nParaguay/M\nParaguayan/S\nParamaribo/M\nParamus/M\nParan\nParcheesi/M\nPareto/M\nParis/M\nParisian/SM\nPark/RMS\nParke/M\nParker/M\nParkersburg/M\nParkhouse/M\nParkinson/M\nParkman\nParliament/MS\nParmesan/S\nParnassus/SM\nParnell/M\nParr/M\nParrish/M\nParrnell/M\nParry/M\nParsee's\nParsifal/M\nParsons/M\nParthenon/M\nParthia/M\nPasadena/M\nPascal/M\nPascale/M\nPaso/M\nPasquale/M\nPassaic/M\nPassion/SM\nPassover/MS\nPasternak/M\nPasteur/M\nPat/MN\nPatagonia/M\nPatagonian/S\nPate/M\nPatel/M\nPaten/M\nPaterson/M\nPatience/M\nPatin/M\nPatna/M\nPaton/M\nPatric/M\nPatrica/M\nPatrice/M\nPatricia/M\nPatricio/M\nPatrick/M\nPatrizia/M\nPatrizio/M\nPatrizius/M\nPatsy/SM\nPatten/M\nPatterson/M\nPatti/M\nPattie/M\nPattin/M\nPatton/M\nPatty/M\nPaul/MG\nPaula/M\nPaule/M\nPauletta/M\nPaulette/M\nPauli/M\nPaulie/M\nPaulina/M\nPauline\nPauling/M\nPaulita/M\nPaulo/M\nPaulsen/M\nPaulson/M\nPaulus/M\nPauly/M\nPavarotti\nPavel/M\nPavia/M\nPavla/M\nPavlov/M\nPavlova/MS\nPavlovian\nPawnee/SM\nPawtucket/M\nPaxon/M\nPaxton/M\nPayne/SM\nPayson/M\nPayton/M\nPaz/M\nPb/M\nPd/M\nPeabody/M\nPeace/M\nPeachtree/M\nPeadar/M\nPeale/M\nPearce/M\nPearl/M\nPearla/M\nPearle/M\nPearlie/M\nPearline/M\nPearson/M\nPeary/M\nPebrook/M\nPechora/M\nPeck/M\nPeckinpah/M\nPecos/M\nPeder/M\nPedro/M\nPeel/M\nPeg/M\nPegasus/MS\nPegeen/M\nPeggi/M\nPeggie/M\nPeggy/M\nPei/M\nPeiping/M\nPeirce/M\nPekinese's\nPeking/SM\nPekingese/SM\nPele/M\nPelee/M\nPelham/M\nPeloponnese/M\nPembroke/M\nPen/M\nPena/M\nPenderecki/M\nPendleton/M\nPenelopa/M\nPenelope/M\nPenn/M\nPenna\nPenney/M\nPenni/M\nPennie/M\nPennington/M\nPennsylvania/M\nPennsylvanian/S\nPenny/M\nPenrod/M\nPensacola/M\nPentagon/M\nPentateuch/M\nPentecost/SM\nPentecostal/S\nPentecostalism/S\nPentium/M\nPeoria/M\nPepe/M\nPepi/M\nPepillo/M\nPepin/M\nPepita/M\nPepito/M\nPepsi/M\nPepsiCo/M\nPepsico/M\nPepys/M\nPequot/M\nPerceval/M\nPercival/M\nPercy/M\nPerelman/M\nPerez/M\nPergamon/M\nPeri/M\nPeria/M\nPerice/M\nPericlean\nPericles/M\nPerilla/M\nPerkin/SM\nPerl/M\nPerla/M\nPerle/M\nPerm/M\nPermalloy/M\nPermian\nPernell/M\nPernod/M\nPeron/M\nPerot/M\nPerren/M\nPerri/M\nPerrine/M\nPerry/MR\nPerseid/M\nPersephone/M\nPerseus/M\nPershing/M\nPersia/M\nPersian/S\nPersis/M\nPerth/M\nPeru/M\nPeruvian/S\nPeshawar/M\nPet/MRZ\nPeta/M\nPete/M\nPeter/M\nPeters/N\nPetersburg/M\nPetersen/M\nPeterson/M\nPeterus/M\nPetey/M\nPetkiewicz/M\nPetr/M\nPetra/M\nPetrarch/M\nPetrina/M\nPetronella/M\nPetronia/M\nPetronilla/M\nPetronille/M\nPettibone/M\nPetty/M\nPetunia/M\nPeugeot/M\nPewaukee/M\nPeyter/M\nPeyton/M\nPfc\nPfizer/M\nPh/M\nPhD\nPhaedra/M\nPhaethon/M\nPhaidra/M\nPhanerozoic\nPharaoh/M\nPharaohs\nPharisaic\nPharisaical\nPharisee/SM\nPhebe/M\nPhedra/M\nPhekda/M\nPhelia/M\nPhelps/M\nPhidias/M\nPhil/MY\nPhiladelphia/M\nPhilbert/M\nPhilco/M\nPhilip/M\nPhilipa/M\nPhilippa/M\nPhilippe/M\nPhilippians/M\nPhilippine/SM\nPhilis/M\nPhilistine/SM\nPhillida/M\nPhillie/M\nPhillip/MS\nPhillipa/M\nPhillipe/M\nPhillipp/M\nPhillis/M\nPhilly/SM\nPhilomena/M\nPhineas/M\nPhip/M\nPhipps/M\nPhobos/M\nPhoebe/M\nPhoenicia/M\nPhoenician/SM\nPhoenix/M\nPhotostat/MS\nPhotostatted\nPhotostatting\nPhylis/M\nPhyllida/M\nPhyllis/M\nPhyllys/M\nPhylys/M\nPia/M\nPiaf/M\nPiaget/M\nPianola/M\nPicasso/M\nPiccadilly/M\nPickering/M\nPickett/M\nPickford/M\nPickman/M\nPickwick/M\nPict/M\nPiedmont/M\nPier/M\nPierce/M\nPierette/M\nPierre/M\nPierrette/M\nPierrot/M\nPierson/M\nPieter/M\nPietra/M\nPietrek/M\nPietro/M\nPiggy/M\nPigmy's\nPike/M\nPilate/M\nPilcomayo/M\nPilgrim\nPillsbury/M\nPinatubo/M\nPincas/M\nPinchas/M\nPincus/M\nPindar/M\nPinehurst/M\nPinkerton/M\nPinocchio/M\nPinochet/M\nPinsky/M\nPinter/M\nPinyin\nPiotr/M\nPip/MR\nPiper/M\nPipestone/M\nPippa/M\nPippo/M\nPippy/M\nPiraeus/M\nPirandello/M\nPisa/M\nPisces/M\nPisistratus/M\nPissaro/M\nPitcairn/M\nPitney/M\nPitt/SM\nPittman/M\nPittsburgh/ZM\nPittsfield/M\nPittston/M\nPius/M\nPizarro/M\nPkwy\nPlainfield/M\nPlainview/M\nPlanck/M\nPlano\nPlantagenet/M\nPlasticine/M\nPlath/M\nPlato/M\nPlatonic\nPlatonism/M\nPlatonist\nPlatte/M\nPlatteville/M\nPlautus/M\nPlayboy/M\nPlaytex/M\nPleiads\nPleistocene\nPlexiglas/MS\nPliny/M\nPliocene/S\nPlutarch/M\nPluto/M\nPlymouth/M\nPm/M\nPo/M\nPocahontas/M\nPocono/MS\nPodgorica/M\nPodunk/M\nPoe/M\nPogo/M\nPoincar/M\nPoindexter/M\nPoisson/M\nPokemon/M\nPol/MY\nPoland/M\nPolanski/M\nPolaris/M\nPolaroid/SM\nPole/MS\nPolish\nPolitburo/M\nPolk/M\nPollard/M\nPollock/SM\nPollux/M\nPolly/M\nPollyanna/M\nPolo/M\nPolyhymnia/M\nPolynesia/M\nPolynesian/S\nPolyphemus/M\nPomerania/M\nPomeranian\nPomona/M\nPompadour/M\nPompeian/S\nPompeii/M\nPompey/M\nPonce/M\nPonchartrain/M\nPontchartrain/M\nPontiac/M\nPontianak/M\nPooh/M\nPoole/M\nPoona/M\nPope/SM\nPopek/MS\nPopeye/M\nPopocatepetl/M\nPopper/M\nPoppins/M\nPoppy/M\nPopsicle/MS\nPorfirio/M\nPorrima/M\nPorsche/M\nPort/MR\nPorte/M\nPorter/M\nPortia/M\nPortie/M\nPortland/M\nPortsmouth/M\nPortugal/M\nPortuguese/M\nPorty/M\nPoseidon/M\nPosner/M\nPost/M\nPotemkin/M\nPotomac/M\nPotsdam/M\nPottawatomie/M\nPotter/M\nPotts/M\nPoughkeepsie/M\nPoul/M\nPound/M\nPoussin/MS\nPowell/M\nPowers\nPowhatan/M\nPoznan/M\nPr/MN\nPradesh/M\nPrado/M\nPraetorian\nPrague/M\nPraia\nPrakrit/M\nPratchett/M\nPratt/M\nPrattville/M\nPravda/M\nPraxiteles/M\nPreakness/M\nPrecambrian\nPreminger/M\nPren/M\nPrent/M\nPrentice/MGD\nPrenticed/M\nPrenticing/M\nPrentiss/M\nPres\nPresbyterian/S\nPresbyterianism/S\nPrescott/M\nPresley/M\nPreston/M\nPretoria/M\nPriam/M\nPribilof/M\nPrice/M\nPriestley/M\nPrime's\nPrince/M\nPrinceton/M\nPrincipe/M\nPrincipia/M\nPrinz/M\nPris\nPrisca/M\nPriscella/M\nPriscilla/M\nPrissie/M\nProcrustean\nProcrustes/M\nProcyon/M\nProf\nProhibition/MS\nProkofieff/M\nProkofiev/M\nPromethean\nPrometheus/M\nProserpine/M\nProtagoras/M\nProterozoic/M\nProtestant/SM\nProtestantism/MS\nProteus/M\nProudhon/M\nProust/M\nProvencals\nProvence/M\nProvenal\nProverbs/M\nProvidence/SM\nProvo/M\nProxmire/M\nProzac\nPru/M\nPrudence/M\nPrudential/M\nPrudi/M\nPrudy/M\nPrue/M\nPruitt/M\nPrussia/M\nPrussian/S\nPrut/M\nPryce/M\nPsalms/M\nPsalter/SM\nPsyche/M\nPt/M\nPtah/M\nPtolemaic\nPtolemaists\nPtolemy/MS\nPu\nPuccini/M\nPuck/M\nPuckett/M\nPuebla/M\nPueblo/MS\nPuerto/M\nPuff/M\nPuget/M\nPugh/M\nPulaski/SM\nPulitzer/SM\nPullman/MS\nPunch/M\nPunic\nPunjab/M\nPunjabi/M\nPurcell/M\nPurdue/M\nPurim/SM\nPurina/M\nPuritan/SM\nPuritanism/MS\nPurus\nPusan/M\nPusey/M\nPushkin/M\nPushtu/M\nPutin/M\nPutnam/M\nPutnem/M\nPvt/M\nPygmalion/M\nPygmy/SM\nPyhrric/M\nPyle/M\nPym/M\nPynchon/M\nPyongyang/M\nPyotr/M\nPyrenees\nPyrex/SM\nPyrrhic\nPythagoras/M\nPythagorean/S\nPythias\nPython/M\nPtain/M\nPrto/M\nQ\nQ's\nQA\nQB\nQC\nQED\nQM\nQaddafi/M\nQantas/M\nQatar/M\nQingdao\nQiqihar/M\nQom/M\nQuaalude/M\nQuaker/SM\nQuakeress/M\nQuakerism/S\nQuantico/M\nQuasimodo/M\nQuaternary\nQuayle/M\nQue/M\nQuebec/M\nQuechua/M\nQueen/SM\nQueenie/M\nQueensland/M\nQuent/M\nQuentin/M\nQuerida/M\nQuetzalcoatl/M\nQuezon/M\nQuill/M\nQuillan/M\nQuincey/M\nQuincy/M\nQuinlan/M\nQuinn/M\nQuint/M\nQuinta/M\nQuintana/M\nQuintilian/M\nQuintilla/M\nQuintin/M\nQuintina/M\nQuinton/M\nQuintus/M\nQuirinal/M\nQuisling/M\nQuito/M\nQuixote/M\nQuixotism/M\nQuonset\nR's\nR/G\nRAF\nRAM/S\nRBI/S\nRC\nRCA\nRCS\nRD\nRDA\nREIT\nREM/S\nRF\nRFC\nRFD\nRI\nRIP\nRISC\nRMS\nRN\nRNA\nROFL\nROM\nROTC\nRP\nRPM\nRR\nRSFSR\nRSI\nRSV\nRSVP\nRSX\nRTFM\nRV\nRVs\nRa/M\nRab/M\nRabat/M\nRabbi/M\nRabelais/M\nRabelaisian\nRabi/M\nRabin/M\nRachael/M\nRachel/M\nRachele/M\nRachelle/M\nRachmaninoff/M\nRacine/M\nRad/M\nRadcliffe/M\nRaddie/M\nRaddy/M\nRae/M\nRaeann/M\nRaf/M\nRafa/M\nRafael/M\nRafaela/M\nRafaelia/M\nRafaelita/M\nRafaellle/M\nRafaello/M\nRafe/M\nRaff/M\nRaffaello/M\nRaffarty/M\nRafferty/M\nRafi/M\nRagnar/M\nRagnark\nRahal/M\nRahel/M\nRaimondo/M\nRaimund/M\nRaimundo/M\nRaina/M\nRaine/MR\nRainer/M\nRainier/M\nRajive/M\nRakel/M\nRaleigh/M\nRalf/M\nRalina/M\nRalph/M\nRalston/M\nRam/M\nRama/M\nRamada/M\nRamadan/SM\nRamakrishna/M\nRaman/M\nRamayana/M\nRambo/M\nRamirez/M\nRamiro/M\nRamo/MS\nRamon/M\nRamona/M\nRamonda/M\nRamsay/M\nRamses/M\nRamsey/M\nRana/M\nRance/M\nRancell/M\nRand/M\nRanda/M\nRandal/M\nRandall/M\nRandee/M\nRandell/M\nRandene/M\nRandi/M\nRandie/M\nRandolf/M\nRandolph/M\nRandy/M\nRanee/M\nRangoon/M\nRani/MR\nRania/M\nRanice/M\nRanier/M\nRanique/M\nRankin/M\nRankine/M\nRanna/M\nRansell/M\nRansom/M\nRaoul/M\nRaphael/M\nRaphaela/M\nRapunzel/M\nRaquel/M\nRaquela/M\nRasalgethi/M\nRasalhague/M\nRasia/M\nRasla/M\nRasmussen/M\nRasputin/M\nRastaban/M\nRastafarian/M\nRastus/M\nRatfor/M\nRather/M\nRatliff/M\nRaul/M\nRavel/M\nRaven/M\nRavi/M\nRavid/M\nRaviv/M\nRawalpindi/M\nRawley/M\nRawlings/M\nRawlins/M\nRawlinson/M\nRawson/M\nRay/M\nRayburn/M\nRaychel/M\nRaye/M\nRayleigh/M\nRaymond/M\nRaymondville/M\nRaymund/M\nRaymundo/M\nRayna/M\nRaynard/M\nRaynell/M\nRayner/M\nRaynor/M\nRayshell/M\nRaytheon/M\nRb\nRd/M\nRe/M\nRea/M\nRead/GM\nReade/M\nReading/M\nReagan/M\nReagen/M\nRealtor/S\nReamonn/M\nReasoner/M\nReba/M\nRebbecca/M\nRebe/M\nRebeca/M\nRebecca's\nRebecka/M\nRebeka/M\nRebekah/M\nRebekkah/M\nRecife/M\nReconstruction/M\nRedd/M\nRedeemer/M\nRedford/M\nRedgrave/M\nRedhook/M\nRedmond/M\nRedondo/M\nRedstone/M\nRee/MDS\nReeba/M\nReebok/M\nReece/M\nReed/M\nReedville/M\nReena/M\nReese/M\nReeta/M\nReeva/M\nReeves\nRefugio/M\nReg/MN\nRegan/M\nRegen/M\nReggi/MS\nReggie/M\nReggy/M\nRegina/M\nReginae\nReginald/M\nReginauld/M\nRegine/M\nRegis/M\nRegor/M\nRegulus/M\nRehnquist\nReich/M\nReichenberg/M\nReichstag's\nReichstags\nReid/MR\nReidar/M\nReider/M\nReiko/M\nReilly/M\nReina/M\nReinald/M\nReinaldo/MS\nReine/M\nReinhard/M\nReinhardt/M\nReinhold/M\nReinold/M\nReinwald/M\nRem/M\nRemarque/M\nRembrandt/M\nRemington/M\nRemus/M\nRemy/M\nRena/M\nRenado/M\nRenae/M\nRenaissance/SM\nRenaldo/M\nRenard/M\nRenascence/SM\nRenata/M\nRenate/M\nRenato/M\nRenaud/M\nRenault/MS\nRene/M\nRenee/M\nRenell/M\nRenelle/M\nRenie/M\nRennie/M\nReno/M\nRenoir/M\nRensselaer/M\nRenville/M\nRep/M\nRepresentative/S\nRepublican/S\nRepublicanism/S\nRequiem/MS\nResistance/SM\nRestoration/M\nReta/M\nRetha/M\nReub/NM\nReube/M\nReuben/M\nReunion/M\nReuters\nReuther/M\nReuven/M\nRev/M\nReva/M\nRevelation/MS\nRevere/M\nReverend\nRevkah/M\nRevlon/M\nRex/M\nRey/M\nReyes\nReykjavik/M\nReyna/M\nReynaldo/M\nReynard/M\nReynold/SM\nRf\nRh/M\nRhea/M\nRheba/M\nRhee/M\nRheims/M\nRheinholdt/M\nRhenish\nRheta/M\nRhett/M\nRhetta/M\nRhiamon/M\nRhianna/M\nRhiannon/M\nRhianon/M\nRhine/M\nRhineland/RM\nRhinelander/M\nRhoda/M\nRhodes\nRhodesia/M\nRhodesian/S\nRhodia/M\nRhodie/M\nRhody/M\nRhona/M\nRhonda/M\nRhone\nRhys/M\nRiane/M\nRiannon/M\nRianon/M\nRibbentrop/M\nRic/M\nRica/M\nRican/SM\nRicard/M\nRicardo/M\nRicca/M\nRiccardo/M\nRice/M\nRich/M\nRichard/MS\nRichardo/M\nRichardson/M\nRichart/M\nRichelieu/M\nRichey/M\nRichfield/M\nRichie/M\nRichland/M\nRichmond/M\nRichmound/M\nRichter/M\nRichthofen/M\nRichy/M\nRici/M\nRick/M\nRickard/M\nRickenbacker/M\nRickenbaugh/M\nRickert/M\nRickey/M\nRicki/M\nRickie/M\nRickover/M\nRicky/M\nRico/M\nRicoriki/M\nRiddle/M\nRide/M\nRidgefield/M\nRidgway/M\nRiemann/M\nRiesling/SM\nRiga/M\nRigel/M\nRiggs/M\nRight/S\nRigoberto/M\nRigoletto/M\nRik/M\nRiki/M\nRikki/M\nRiley/M\nRilke/M\nRimbaud/M\nRina/M\nRinaldo/M\nRinehart/M\nRing/M\nRingling/M\nRingo/M\nRio/MS\nRiobard/M\nRiordan/M\nRip/M\nRipley/M\nRisa/M\nRita/M\nRitalin\nRitchie/M\nRitter/M\nRitz/M\nRiva/MS\nRivalee/M\nRivera/M\nRivers\nRiverside/M\nRiverview/M\nRivi/M\nRiviera/MS\nRivkah/M\nRivy/M\nRiyadh/M\nRn/M\nRoach/M\nRoana/M\nRoanna/M\nRoanne/M\nRoanoke/M\nRoarke/M\nRob/MZ\nRobb/M\nRobbert/M\nRobbi/M\nRobbie/M\nRobbin/MS\nRobby/M\nRobbyn/M\nRobena/M\nRobenia/M\nRobers/M\nRoberson/M\nRobert/MS\nRoberta/M\nRoberto/M\nRobertson/SM\nRobeson/M\nRobespierre/M\nRobin/M\nRobina/M\nRobinet/M\nRobinett/M\nRobinetta/M\nRobinette/M\nRobinia/M\nRobinson/M\nRobinsonville/M\nRobles/M\nRobson/M\nRobt/M\nRoby/M\nRobyn/M\nRocco/M\nRoch/M\nRocha/M\nRochambeau/M\nRoche/M\nRochell/M\nRochella/M\nRochelle/M\nRochester/M\nRochette/M\nRock/M\nRockaway/MS\nRockefeller/M\nRockey/M\nRockford/M\nRockie/M\nRockland/M\nRockne/M\nRockville/M\nRockwell/M\nRocky/SM\nRod/M\nRoda/M\nRodd/M\nRoddenberry/M\nRoddie/M\nRoddy/M\nRoderic/M\nRoderich/M\nRoderick/M\nRoderigo/M\nRodge/ZMR\nRodger/M\nRodi/M\nRodie/M\nRodin/M\nRodina/M\nRodney/M\nRodolfo/M\nRodolph/M\nRodolphe/M\nRodrick/M\nRodrigo/M\nRodriguez/M\nRodrique/M\nRodriquez/M\nRoentgen's\nRog/MRZ\nRogelio/M\nRoger/M\nRogerio/M\nRoget/M\nRoi/SM\nRojas/M\nRoland/M\nRolando/M\nRoldan/M\nRoley/M\nRolf/M\nRolfe/M\nRolland/M\nRollerblade/S\nRollie/M\nRollin/SM\nRollo/M\nRolodex\nRolph/M\nRolvaag/M\nRom/SM\nRoma/M\nRomain/M\nRoman/SM\nRomanesque/S\nRomania/M\nRomanian/SM\nRomano/MS\nRomanov/M\nRomans/M\nRomansh/M\nRomanticism/S\nRomany/SM\nRome/SM\nRomeo/MS\nRomero/M\nRommel/M\nRomney/M\nRomola/M\nRomona/M\nRomonda/M\nRomulus/M\nRomy/M\nRon/M\nRona/M\nRonald/M\nRonalda/M\nRonda/M\nRonica/M\nRonna/M\nRonni/M\nRonnica/M\nRonnie/M\nRonny/M\nRonstadt/M\nRontgen\nRoobbie/M\nRooney/M\nRoosevelt/M\nRooseveltian\nRoot/M\nRoquefort/MS\nRoquemore/M\nRora/M\nRori/M\nRorie/M\nRorke/M\nRorschach\nRory/M\nRos/N\nRosa/M\nRosabel/M\nRosabella/M\nRosabelle/M\nRosaleen/M\nRosales/M\nRosalia/M\nRosalie/M\nRosalind/M\nRosalinda/M\nRosalinde/M\nRosaline/M\nRosalyn/M\nRosalynd/M\nRosamond/M\nRosamund/M\nRosana/M\nRosanna/M\nRosanne/M\nRosario/M\nRosco/M\nRoscoe/M\nRose/M\nRoseann/M\nRoseanna/M\nRoseanne/M\nRoseau\nRosecrans/M\nRoseland/M\nRoselia/M\nRoselin/M\nRoseline/M\nRosella/M\nRoselle/M\nRosemaria/M\nRosemarie/M\nRosemary/M\nRosemonde/M\nRosen/M\nRosenberg/M\nRosenblum/M\nRosendo/M\nRosene/M\nRosenthal/M\nRosenzweig/M\nRosetta/M\nRosette/M\nRoshelle/M\nRosicrucian/M\nRosie/M\nRosina/M\nRosita/M\nRoslyn/M\nRosmunda/M\nRoss\nRossetti/M\nRossi/M\nRossie/M\nRossini/M\nRossy/M\nRostand/M\nRostov/M\nRoswell/M\nRosy/M\nRotarian/SM\nRoth/M\nRothschild/M\nRotterdam/M\nRouault/M\nRourke/M\nRousseau/M\nRouvin/M\nRover/M\nRow/MN\nRowan/M\nRowe/M\nRowen/M\nRowena/M\nRowland/M\nRowley/M\nRowney/M\nRoxana/M\nRoxane/M\nRoxanna/M\nRoxanne/M\nRoxi/M\nRoxie/M\nRoxine/M\nRoxy/M\nRoy/M\nRoyal/M\nRoyall/M\nRoyce/M\nRoz/M\nRozalie/M\nRozalin/M\nRozamond/M\nRozanna/M\nRozanne/M\nRoze/M\nRozele/M\nRozella/M\nRozelle/M\nRozina/M\nRriocard/M\nRte\nRu/MH\nRubaiyat/M\nRube/M\nRuben/MS\nRubetta/M\nRubi/M\nRubia/M\nRubicon/SM\nRubie/M\nRubik/M\nRubin/M\nRubina/M\nRubinstein/M\nRuby/M\nRuchbah/M\nRudd/M\nRuddie/M\nRuddy/M\nRudie/M\nRudiger/M\nRudolf/M\nRudolfo/M\nRudolph/M\nRudy/M\nRudyard/M\nRufe/M\nRufus/M\nRugby's\nRuggiero/M\nRuhr/M\nRuiz/M\nRumania's\nRumanian's\nRumford/M\nRummel/M\nRumpelstiltskin/M\nRunge/M\nRunnymede/M\nRunyon/M\nRupert/M\nRuperta/M\nRuperto/M\nRuppert/M\nRuprecht/M\nRurik/M\nRush/M\nRushdie/M\nRushmore/M\nRuskin/M\nRuss/S\nRussel/M\nRussell/M\nRussia/M\nRussian/SM\nRusso/M\nRustbelt/M\nRustie/M\nRustin/M\nRusty/M\nRutger/SM\nRuth/M\nRuthann/M\nRuthanne/M\nRuthe/M\nRutherford/M\nRuthi/M\nRuthie/M\nRuthy/M\nRutland/M\nRutledge/M\nRutter/M\nRuttger/M\nRuy/M\nRwanda/SM\nRwandan/S\nRwy/M\nRx/M\nRy/M\nRyan/M\nRyann/M\nRycca/M\nRydberg/M\nRyder/M\nRyley/M\nRyon/M\nRyukyu/M\nRyun/M\nS\nS's\nSA\nSAC\nSALT\nSAM\nSASE\nSAT\nSBA\nSC\nSCCS\nSCSI\nSD\nSDI\nSE\nSEATO\nSEC\nSF\nSIDS\nSIGGRAPH/M\nSIMD\nSIMULA/M\nSJ\nSK\nSLR\nSMSA/MS\nSMTP\nSO\nSOP\nSOS\nSPARC/M\nSPARCstation/M\nSPCA\nSPF\nSPSS\nSRO\nSS\nSSA\nSSE\nSSS\nSST\nSSW\nST\nSTD\nSTOL\nSUV\nSW\nSWAK\nSWAT\nSaab/M\nSaar/M\nSaba/M\nSabbath/M\nSabbaths\nSabik/M\nSabin/M\nSabina/M\nSabine/M\nSabra/M\nSabrina/M\nSacajawea/M\nSacco/M\nSacha/M\nSachs/M\nSacramento/M\nSada/M\nSadat/M\nSaddam/M\nSadducee/M\nSade/M\nSadella/M\nSadie/M\nSadr/M\nSadye/M\nSagan/M\nSaginaw/M\nSagittarius/MS\nSahara/M\nSaharan/M\nSahel\nSaidee/M\nSaigon/M\nSaiph/M\nSakai/M\nSakhalin/M\nSakharov/M\nSaki/M\nSal/MY\nSaladin/M\nSalado/M\nSalaidh/M\nSalas/M\nSalazar/M\nSaleem/M\nSalem/M\nSalerno/M\nSalim/M\nSalina/MS\nSalinger/M\nSalisbury/M\nSalish/M\nSalk/M\nSalle/M\nSallee/M\nSalli/M\nSallie/M\nSallust/M\nSally/M\nSallyann/M\nSallyanne/M\nSalmon/M\nSaloma/M\nSalome/M\nSalomi/M\nSalomo/M\nSalomon/M\nSalomone/M\nSalonika/M\nSalton/M\nSalvador/M\nSalvadoran/S\nSalvadorian/S\nSalvatore/M\nSalvidor/M\nSalween/M\nSalyut/M\nSalz/M\nSam/M\nSamantha/M\nSamara/M\nSamaria/M\nSamaritan/MS\nSamarkand/M\nSammie/M\nSammy/M\nSamoa\nSamoan/S\nSamoset/M\nSamoyed/M\nSampson/M\nSamson/M\nSamsonite/M\nSamuel/SM\nSamuele/M\nSamuelson/M\nSan'a\nSan/M\nSana/M\nSanborn/M\nSanchez/M\nSancho/M\nSand/MRZ\nSandburg/M\nSande/M\nSander/M\nSanderling/M\nSanderson/M\nSandi/M\nSandia/M\nSandie/M\nSandinista\nSandor/M\nSandoval/M\nSandra/M\nSandro/M\nSandusky/M\nSandy/M\nSandye/M\nSanford/M\nSanforized\nSang/RM\nSanger/M\nSanhedrin/M\nSankara/M\nSanskrit/M\nSanskritic\nSanskritize/M\nSanson/M\nSansone/M\nSanta/M\nSantana/M\nSantayana/M\nSanteria\nSantiago/M\nSanto/MS\nSapphira/M\nSapphire/M\nSappho/M\nSapporo/M\nSara/M\nSaraann/M\nSaracen/MS\nSaragossa/M\nSarah/M\nSarajane/M\nSarajevo/M\nSaran/M\nSarasota/M\nSaratoga/M\nSaratov/M\nSarawak/M\nSardinia/M\nSaree/M\nSarena/M\nSarene/M\nSarette/M\nSargasso/M\nSarge/M\nSargent/M\nSargon/M\nSari/M\nSarina/M\nSarine/M\nSarita/M\nSarnoff/M\nSaroyan/M\nSarto/M\nSartre/M\nSascha/M\nSasha/M\nSashenka/M\nSask/M\nSaskatchewan/M\nSaskatoon/M\nSassoon/M\nSat/M\nSatan/M\nSatanism/M\nSatanist/M\nSaturday/MS\nSaturn/M\nSaturnalia/M\nSatyanarayanan/M\nSaud/M\nSaudi/S\nSaudra/M\nSaukville/M\nSaul/M\nSault/M\nSauncho/M\nSaunder/SM\nSaunderson/M\nSaundra/M\nSaussure/M\nSauternes/M\nSauveur/M\nSavage/M\nSavannah/M\nSavina/M\nSavior/M\nSaviour/M\nSavonarola/M\nSavoy/M\nSavoyard/M\nSaw/M\nSawyer/M\nSawyere/M\nSax/M\nSaxe/M\nSaxon/SM\nSaxony/M\nSaxton/M\nSay/ZMR\nSayer/M\nSayre/MS\nSb/M\nSc/M\nScala/M\nScan\nScandinavia/M\nScandinavian/S\nScaramouch/M\nScarborough/M\nScarface/M\nScarlatti/M\nScarlet/M\nScarlett/M\nSchaefer/M\nSchaeffer/M\nSchafer/M\nSchaffner/M\nSchantz/M\nSchapiro/M\nScheat/M\nSchedar/M\nScheherazade/M\nScheherezade/M\nSchelling/M\nSchenectady/M\nSchick/M\nSchiller/M\nSchlesinger/M\nSchliemann/M\nSchlitz/M\nSchloss/M\nSchmidt/M\nSchmitt/M\nSchnabel/M\nSchneider/M\nSchoenberg/M\nSchofield/M\nSchopenhauer/M\nSchottky/M\nSchrieffer/M\nSchroeder/M\nSchroedinger/M\nSchrdinger/M\nSchubert/M\nSchultz/M\nSchulz/M\nSchumacher/M\nSchuman/M\nSchumann/M\nSchuster/M\nSchuyler/M\nSchuylkill/M\nSchwab/M\nSchwartz/M\nSchwartzkopf/M\nSchwarzenegger/M\nSchweitzer/M\nSchweppes/M\nSchwinger/M\nSchwinn/M\nScientology/M\nScipio/M\nScopes/M\nScorpio/SM\nScorpius/M\nScorsese/M\nScot/MS\nScotch/S\nScotchgard/M\nScotchman/M\nScotchmen\nScotchwoman\nScotchwomen\nScotia/M\nScotian/M\nScotland/M\nScotsman/M\nScotsmen\nScotswoman\nScotswomen\nScott/M\nScotti/M\nScottie/SM\nScottish\nScottsdale/M\nScotty's\nScout's\nScrabble/SM\nScranton/M\nScriabin/M\nScribner/MS\nScripps/M\nScripture/MS\nScrooge/MS\nScruggs/M\nScud/M\nSculley/M\nScylla/M\nScythia/M\nSe/H\nSeaborg/M\nSeabrook/M\nSeagate/M\nSeagram/M\nSeamus/M\nSean/M\nSeana/M\nSeaquarium/M\nSears/M\nSeattle/M\nSebastian/M\nSebastiano/M\nSebastien/M\nSeconal\nSeder/SM\nSedgwick/M\nSee/M\nSeebeck/M\nSeeley/M\nSegovia/M\nSegre/M\nSegundo/M\nSeidel/M\nSeiko/M\nSeine/M\nSeinfeld/M\nSeka/M\nSela/M\nSelassie/M\nSelby/M\nSelectric/M\nSelena/M\nSelene/M\nSelestina/M\nSeleucid/M\nSeleucus/M\nSelfridge/M\nSelia/M\nSelie/M\nSelig/M\nSelim/M\nSelina/M\nSelinda/M\nSeline/M\nSeljuk/M\nSelkirk/M\nSella/M\nSelle/ZM\nSellers/M\nSelma/M\nSelznick/M\nSemarang/M\nSeminole/SM\nSemiramis/M\nSemite/SM\nSemitic/MS\nSemtex\nSen\nSena/M\nSenate/MS\nSendai/M\nSeneca/MS\nSenegal/M\nSenegalese\nSenior/S\nSennacherib/M\nSennett/M\nSensurround/M\nSeoul/M\nSephardi/M\nSephira/M\nSepoy/M\nSept/M\nSeptember/MS\nSeptuagint/MS\nSequoia/M\nSequoya/M\nSerafin/M\nSerb/MS\nSerbia/M\nSerbian/S\nSerbo/M\nSerena/M\nSerene/M\nSerengeti/M\nSerge/M\nSergeant/M\nSergei/M\nSergent/M\nSergio/M\nSerpens/M\nSerra/M\nSerrano/M\nSet/M\nSeth/M\nSeton/M\nSeumas/M\nSeurat/M\nSeuss/M\nSevastopol/M\nSevern/M\nSeverus/M\nSeville/M\nSeward/M\nSextans/M\nSexton/M\nSeychelles\nSeyfert\nSeymour/M\nSeora/M\nSgt\nShackleton/M\nShadow/M\nShae/M\nShafer/M\nShaffer/M\nShaina/M\nShaine/M\nShaker/S\nShakespeare/M\nShakespearean/S\nShakespearian\nShalna/M\nShalne/M\nShalom/M\nShamus/M\nShana/M\nShanan/M\nShanda/M\nShandee/M\nShandeigh/M\nShandie/M\nShandra/M\nShandy/M\nShane/M\nShanghai/GM\nShanghaiing/M\nShani/M\nShanie/M\nShanna/M\nShannah/M\nShannan/M\nShannen/M\nShannon/M\nShanon/M\nShanta/M\nShantee/M\nShantung/M\nShapiro/M\nShara/M\nSharai/M\nShari'a\nShari/M\nSharia/M\nSharity/M\nSharl/M\nSharla/M\nSharleen/M\nSharlene/M\nSharline/M\nSharon/M\nSharona/M\nSharp/M\nSharpe/M\nSharron/M\nSharyl/M\nShasta/M\nShaughn/M\nShaula/M\nShaun/M\nShauna/M\nShavian\nShavuot/M\nShaw/M\nShawano/M\nShawn/M\nShawna/M\nShawnee/SM\nShay/M\nShayla/M\nShaylah/M\nShaylyn/M\nShaylynn/M\nShayna/M\nShayne/M\nShcharansky/M\nShea/M\nSheba/M\nShebeli/M\nSheboygan/M\nShedir/M\nSheela/M\nSheelagh/M\nSheelah/M\nSheena/M\nSheeree/M\nSheetrock\nSheff/M\nSheffie/M\nSheffield/RMZ\nSheffielder/M\nSheffy/M\nSheila/M\nSheilah/M\nShel/MY\nShela/M\nShelagh/M\nShelba/M\nShelbi/M\nShelby/M\nShelden/M\nSheldon/M\nShelia/M\nShell/M\nShelley/M\nShelli/M\nShellie/M\nShelly/M\nShelton/M\nShem/M\nShena/M\nShenandoah/M\nShenyang/M\nSheol/M\nShep/M\nShepard/M\nShepherd/M\nSheppard/M\nShepperd/M\nSher/M\nSheratan/M\nSheraton/M\nSheree/M\nSheri/M\nSheridan/M\nSherie/M\nSherill/M\nSherilyn/M\nSherline/M\nSherlock/M\nSherlocke/M\nSherm/M\nSherman/M\nShermie/M\nShermy/M\nSherpa/SM\nSherri/M\nSherrie/M\nSherry/M\nSherwin/M\nSherwood/M\nSherwynd/M\nSherye/M\nSheryl/M\nShetland/S\nShevardnadze/M\nShi'ite\nShields/M\nShiite/SM\nShijiazhuang\nShikoku/M\nShillong/M\nShiloh/M\nShina/M\nShinto/MS\nShintoism/S\nShintoist/MS\nShir/M\nShiraz/M\nShirl/M\nShirlee/M\nShirleen/M\nShirlene/M\nShirley/M\nShirline/M\nShiva/M\nShmuel/M\nShockley/M\nShoji/M\nSholom/M\nShorewood/M\nShort/M\nShorthorn/M\nShoshana/M\nShoshanna/M\nShoshone/SM\nShostakovitch/M\nShreveport/M\nShropshire/M\nShu/M\nShulman/M\nShurlock/M\nShurlocke/M\nShurwood/M\nShuttleworth\nShuttleworth's\nShylock/M\nShylockian/M\nSi/M\nSiam/M\nSiamese/M\nSian's\nSiana/M\nSianna/M\nSib/M\nSibbie/M\nSibby/M\nSibeal/M\nSibel/M\nSibelius/M\nSibella/M\nSibelle/M\nSiberia/M\nSiberian/S\nSibilla/M\nSibley/M\nSibyl/M\nSibylla/M\nSibylle/M\nSicilian/S\nSiciliana/M\nSicily/M\nSid/M\nSidnee/M\nSidney/M\nSidoney/M\nSidonia/M\nSidonnie/M\nSiegel/M\nSiegfried/M\nSieglinda/M\nSiegmund/M\nSiemens/M\nSiena/M\nSierpinski/M\nSiffre/M\nSig/M\nSigfrid/M\nSigfried/M\nSigismond/M\nSigismondo/M\nSigismund/M\nSigismundo/M\nSigmund/M\nSignor/M\nSignora/M\nSigrid/M\nSigurd/M\nSigvard/M\nSihanouk/M\nSikh/MS\nSikhism/MS\nSikhs\nSikkim/M\nSikkimese\nSikorsky/M\nSilas/M\nSile/M\nSileas/M\nSilesia/M\nSilurian/S\nSilva/M\nSilvain/M\nSilvan/M\nSilvana/M\nSilvano/M\nSilvanus/M\nSilverman/M\nSilverstein/M\nSilvester/M\nSilvia/M\nSilvie/M\nSilvio/M\nSim/MS\nSimenon/M\nSimeon/M\nSimla/M\nSimmonds/M\nSimmons/M\nSimmonsville/M\nSimms/M\nSimon/M\nSimona/M\nSimone/M\nSimonette/M\nSimonne/M\nSimpson/M\nSimula/M\nSinai/M\nSinatra/M\nSinclair/M\nSinclare/M\nSindbad/M\nSindee/M\nSindhi/M\nSingapore/M\nSingaporean/S\nSingborg/M\nSinger/M\nSingleton/M\nSinhalese/M\nSinkiang/M\nSiobhan/M\nSioux/M\nSiouxie/M\nSir/MS\nSirius/M\nSisely/M\nSisile/M\nSissie/M\nSissy/M\nSistine\nSisyphean\nSisyphus/M\nSiusan/M\nSiva/M\nSiward/M\nSjaelland/M\nSkell/M\nSkelly/M\nSkinner/M\nSkip/M\nSkipp/RM\nSkipper/M\nSkippie/M\nSkippy/M\nSkipton/M\nSkopje/M\nSky/M\nSkye/M\nSkylab/M\nSkylar/M\nSkyler/M\nSlade/M\nSlater/M\nSlav/MS\nSlavic/M\nSlavonic/M\nSlesinger/M\nSloan/M\nSloane/M\nSlocum/M\nSlovak/S\nSlovakia/M\nSlovakian/S\nSlovene/S\nSlovenia/M\nSlovenian/S\nSly/M\nSm/M\nSmall/M\nSmallwood/M\nSmetana/M\nSmirnoff/M\nSmith/M\nSmithfield/M\nSmithson/M\nSmithsonian/M\nSmithtown/M\nSmitty/M\nSmokey/M\nSmolensk/M\nSmollett/M\nSmucker/M\nSmuts/M\nSmyrna/M\nSn/M\nSnake\nSnead/M\nSneed/M\nSnell/M\nSnider/M\nSnodgrass/M\nSnoopy/M\nSnow/M\nSnowbelt/SM\nSnyder/M\nSoc\nSocorro/M\nSocrates/M\nSocratic/S\nSoddy/M\nSodom/M\nSofia/M\nSofie/M\nSoho/M\nSol/MY\nSolis/M\nSollie/M\nSolly/M\nSolomon/SM\nSolon/M\nSoloviev/M\nSolzhenitsyn/M\nSomali/MS\nSomalia/M\nSomalian/S\nSomerset/M\nSomerville/M\nSomme/M\nSomoza/M\nSon/M\nSondheim/M\nSondra/M\nSonenberg/M\nSonghai/M\nSonghua/M\nSonia/M\nSonja/M\nSonni/M\nSonnie/M\nSonnnie/M\nSonny/M\nSonoma/M\nSonora/M\nSontag/M\nSony/M\nSonya/M\nSophey/M\nSophi/M\nSophia/SM\nSophie/M\nSophoclean\nSophocles/M\nSophronia/M\nSopwith/M\nSorbonne/M\nSorcha/M\nSorensen/M\nSorenson/M\nSorrentine/M\nSosa/M\nSosanna/M\nSoto/M\nSouphanouvong/M\nSousa/M\nSouth/M\nSouthampton/M\nSoutheast/MS\nSoutherner/MS\nSouthey/M\nSouthfield/M\nSouths\nSouthwest/MS\nSoviet/S\nSoweto/M\nSoyinka/M\nSoyuz/M\nSp/M\nSpaatz/M\nSpacewar/M\nSpackle\nSpafford/M\nSpahn/M\nSpain/M\nSpalding/M\nSpam/M\nSpan\nSpanglish/S\nSpaniard/SM\nSpanish/M\nSparkman/M\nSparks\nSparta/M\nSpartacus/M\nSpartan/S\nSpeaker's\nSpears\nSpence/RM\nSpencer/M\nSpencerian\nSpengler/M\nSpenglerian\nSpense/MR\nSpenser/M\nSpenserian\nSperry/M\nSphinx/M\nSpica/M\nSpiegel/M\nSpielberg/M\nSpike/M\nSpillane/M\nSpinoza/M\nSpiro/M\nSpitz/M\nSpock/M\nSpokane/M\nSposato/M\nSpringfield/M\nSpringsteen/M\nSprint/M\nSproul/M\nSpuds/M\nSputnik\nSquanto\nSquaresville/M\nSquibb/GM\nSquibbing/M\nSr\nSrinagar/M\nSt/M\nSta/M\nStace/M\nStacee/M\nStacey/M\nStaci/M\nStacia/M\nStacie/M\nStacy/M\nStael/M\nStafani/M\nStaffard/M\nStafford/M\nStaffordshire/M\nStaford/M\nStahl/M\nStaley/M\nStalin/SM\nStalingrad/M\nStalinist\nStallone/M\nStamford/M\nStan/YMS\nStandford/M\nStandish/M\nStanfield/M\nStanford/M\nStanislas/M\nStanislaus/M\nStanislavsky/M\nStanislaw/M\nStanleigh/M\nStanley/M\nStanly/M\nStanton/M\nStanwood/M\nStapleton/M\nStar/M\nStargate/M\nStark/M\nStarkey/M\nStarla/M\nStarlene/M\nStarlin/M\nStarr/M\nStatehouse's\nStaten/M\nStatler/M\nStauffer/M\nStavro/MS\nSte/M\nStearn/SM\nStearne/M\nSteele/M\nSteen/M\nStefa/M\nStefan/M\nStefania/M\nStefanie/M\nStefano/M\nSteffane/M\nSteffen/M\nSteffi/M\nSteffie/M\nStein/RM\nSteinbeck/SM\nSteinberg/M\nSteinem/M\nSteiner/M\nSteinmetz/M\nSteinway/M\nStella/M\nStendhal/M\nStendler/M\nStengel/M\nStepha/M\nStephan/M\nStephana/M\nStephani/M\nStephanie/M\nStephannie/M\nStephanus/M\nStephen/MS\nStephenie/M\nStephenson/M\nStephi/M\nStephie/M\nStephine/M\nSterling/M\nStern/M\nSternberg/M\nSterne/M\nSterno\nStesha/M\nStetson/SM\nSteuben/M\nStevana/M\nSteve/M\nSteven/MS\nStevena/M\nStevenson/M\nStevie/M\nStevy/M\nSteward/M\nStewart/M\nStieglitz/M\nStillman/M\nStillmann/M\nStillwell/M\nStilton/MS\nStimson/M\nStine/M\nStinky/M\nStirling/M\nStockhausen/M\nStockholm/M\nStockton/M\nStoddard/M\nStoic/MS\nStoicism/SM\nStokes/M\nStone/M\nStonehenge/M\nStoppard/M\nStorm/M\nStormi/M\nStormie/M\nStormy/M\nStouffer/M\nStout/M\nStowe/M\nStrabo/M\nStradivari/SM\nStradivarius/M\nStrasbourg/M\nStratford/M\nStrauss\nStravinsky/M\nStreisand/M\nStrickland/M\nStrindberg/M\nStrom/M\nStromberg/M\nStromboli/M\nStrong/M\nStrongheart/M\nStu/M\nStuart/MS\nStubblefield/MS\nStudebaker/M\nSturm/M\nStuttgart/M\nStuyvesant/M\nStygian\nStyrofoam/S\nStyx/M\nSuarez/M\nSubaru/M\nSucre/M\nSudan/M\nSudanese/M\nSudanic/M\nSudetenland/M\nSue/M\nSuellen/M\nSuetonius/M\nSuez/M\nSuffolk/M\nSufi/M\nSufism/M\nSuharto/M\nSui/M\nSukarno/M\nSukey/M\nSuki/M\nSukkot/S\nSukkoth's\nSula/M\nSulawesi/M\nSuleiman/M\nSulla/M\nSullivan/M\nSully/M\nSulzberger/M\nSumatra/M\nSumatran/S\nSumeria/M\nSumerian/M\nSummer/SM\nSummerdale/M\nSumner/M\nSumter/M\nSun\nSunbelt/M\nSundanese/M\nSundas\nSunday/MS\nSung/M\nSunni/MS\nSunnite/SM\nSunny/M\nSunnyvale/M\nSunshine/M\nSuperior/M\nSuperman/M\nSupt/M\nSurabaya/M\nSurat/M\nSurinam's\nSuriname\nSurinamese\nSurya/M\nSus\nSusan/M\nSusana/M\nSusanetta/M\nSusann/M\nSusanna/M\nSusannah/M\nSusanne/M\nSusette/M\nSusi/M\nSusie/M\nSusquehanna/M\nSussex/M\nSusy/M\nSutherlan/M\nSutherland/M\nSutton/M\nSuva/M\nSuwanee/M\nSuzann/M\nSuzanna/M\nSuzanne/M\nSuzette/M\nSuzhou/M\nSuzi/M\nSuzie/M\nSuzuki/M\nSuzy/M\nSvalbard/M\nSven/M\nSvend/M\nSvengali\nSverdlovsk/M\nSvetlana/M\nSwabian/SM\nSwahili/MS\nSwanee/M\nSwansea/M\nSwanson/M\nSwarthmore/M\nSwartz/M\nSwazi/SM\nSwaziland/M\nSwed/MN\nSwede/SM\nSweden/M\nSwedenborg/M\nSwedish\nSweeney/SM\nSweet/M\nSwen/M\nSwenson/M\nSwift/M\nSwinburne/M\nSwink/M\nSwiss/S\nSwitz/MR\nSwitzer/M\nSwitzerland/M\nSybil/M\nSybila/M\nSybilla/M\nSybille/M\nSybyl/M\nSyd/M\nSydel/M\nSydelle/M\nSydney/M\nSykes/M\nSylas/M\nSylow/M\nSylvan/M\nSylvania/M\nSylvester/M\nSylvia/M\nSylvie/M\nSyman/M\nSymington/M\nSymon/M\nSynge/M\nSyracuse/M\nSyria/M\nSyriac/M\nSyrian/SM\nSzilard/M\nSzymborska/M\nT'ang\nT's\nT/G\nTA\nTB\nTBA\nTCP\nTD\nTDD\nTEFL\nTELNET/M\nTENEX/M\nTESL\nTESOL\nTEirtza/M\nTHC\nTKO\nTLC\nTM\nTN\nTNT\nTOEFL\nTRW\nTTL\nTV/M\nTVA\nTVs\nTWA/M\nTWX\nTX\nTa/M\nTab/MR\nTabasco/MS\nTabatha/M\nTabb/M\nTabbatha/M\nTabbi/M\nTabbie/M\nTabbitha/M\nTabby/M\nTaber/M\nTabernacle/S\nTabina/M\nTabitha/M\nTabor/M\nTabriz/SM\nTacitus/M\nTacoma/M\nTad/M\nTadd/M\nTaddeo/M\nTaddeusz/M\nTadeas/M\nTadeo/M\nTades\nTadio/M\nTadzhikistan's\nTadzhikstan/M\nTaegu/M\nTaejon/M\nTaffy/M\nTaft/M\nTagalog/SM\nTagore/M\nTagus/M\nTahiti/M\nTahitian/S\nTahoe/M\nTaichung/M\nTailor/M\nTainan/M\nTaine/M\nTaipei/M\nTait/M\nTaite/M\nTaiwan/M\nTaiwanese\nTaiyuan/M\nTajikistan\nTaklamakan/M\nTalbert/M\nTalbot/M\nTalia/M\nTaliesin/M\nTalladega/M\nTallahassee/M\nTallahatchie/M\nTallahoosa/M\nTallchief/M\nTalley/M\nTalleyrand/M\nTallia/M\nTallie/M\nTallinn/M\nTallou/M\nTallulah/M\nTally/M\nTalmud/MS\nTalmudic\nTalmudist/MS\nTalya/M\nTalyah/M\nTam/M\nTamar/M\nTamara/M\nTamarah/M\nTamarra/M\nTamas\nTameka/M\nTamera/M\nTamerlane/M\nTami/M\nTamika/M\nTamiko/M\nTamil/MS\nTamma/M\nTammany/M\nTammara/M\nTammi/M\nTammie/M\nTammy/M\nTampa/M\nTampax/M\nTamqrah/M\nTamra/M\nTan/M\nTana/M\nTanaka/M\nTananarive/M\nTancred/M\nTandi/M\nTandie/M\nTandy/M\nTaney/M\nTanganyika/M\nTangier/M\nTangshan/M\nTanhya/M\nTani/M\nTania/M\nTanisha/M\nTanitansy/M\nTann/RM\nTannenbaum/M\nTanner/M\nTanney/M\nTannhuser/M\nTannie/M\nTanny/M\nTansy/M\nTantalus/M\nTanya/M\nTanzania/M\nTanzanian/S\nTao/M\nTaoism/MS\nTaoist/MS\nTapdance/M\nTara/M\nTarah/M\nTarawa/M\nTarazed/M\nTarbell/M\nTarim/M\nTarkington/M\nTarra/M\nTarrah/M\nTarrance/M\nTarrytown/M\nTartar's\nTartary/M\nTartuffe/M\nTaryn/M\nTarzan/M\nTasha/M\nTashkent/M\nTasia/M\nTasmania/M\nTasmanian/S\nTass/M\nTatar/SM\nTate/M\nTatiana/M\nTatiania/M\nTatum/M\nTaurus/SM\nTawney/M\nTawnya/M\nTawsha/M\nTaylor/SM\nTb\nTbilisi/M\nTc/M\nTchaikovsky/M\nTe\nTeX/M\nTeador/M\nTeasdale/M\nTechnicolor/MS\nTechnion/M\nTecumseh/M\nTed/M\nTedd/M\nTedda/M\nTeddi/M\nTeddie/M\nTeddy/M\nTedi/M\nTedie/M\nTedman/M\nTedmund/M\nTedra/M\nTeena/M\nTeflon/MS\nTegucigalpa/M\nTeheran's\nTehran\nTektronix/M\nTelePrompTer/S\nTelePrompter/M\nTeledyne/M\nTelefunken/M\nTelemachus/M\nTelemann/M\nTeletype/SM\nTelex/M\nTell/MR\nTeller/M\nTelnet/M\nTelugu/M\nTemp/M\nTempe/M\nTemple/M\nTempleman/M\nTempleton/M\nTenex/M\nTenn/M\nTenneco/M\nTennessean/S\nTennessee/M\nTenney/M\nTennyson/M\nTenochtitlan/M\nTeodoor/M\nTeodor/M\nTeodora/M\nTeodorico/M\nTeodoro/M\nTera/M\nTerence/M\nTerencio/M\nTeresa/M\nTerese/M\nTereshkova/M\nTeresina/M\nTeresita/M\nTeressa/M\nTeri/M\nTeriann/M\nTerkel/M\nTerpsichore/M\nTerra/M\nTerran/M\nTerrance/M\nTerre/M\nTerrel/M\nTerrell/M\nTerrence/M\nTerri/M\nTerrie/M\nTerrijo/M\nTerrill/M\nTerritorial/SM\nTerritory's\nTerry/M\nTerrye/M\nTersina/M\nTertiary\nTerza/M\nTesla/M\nTess/M\nTessa/M\nTessi/M\nTessie/M\nTessy/M\nTethys/M\nTetons\nTeuton/SM\nTeutonic\nTex/M\nTexaco/M\nTexan/S\nTexas/MS\nTextron/M\nTh/M\nThacher/M\nThackeray/M\nThad/M\nThaddeus/M\nThaddus/M\nThadeus/M\nThai/S\nThailand/M\nThain/M\nThaine/M\nThales/M\nThalia/M\nThames\nThane/M\nThanh/M\nThanksgiving/S\nThant/M\nThar/M\nThatch/MR\nThatcher/M\nThaxter/M\nThayer/M\nThayne/M\nThea/M\nTheadora/M\nThebault/M\nThebes\nTheda/M\nThedric/M\nThedrick/M\nTheiler/M\nThekla/M\nThelma/M\nThemistocles/M\nTheo/M\nTheobald/M\nTheocritus/M\nTheodor/M\nTheodora/M\nTheodore/M\nTheodoric/M\nTheodosia/M\nTheodosian\nTheodosius/M\nTheosophy\nTheravada/M\nTheresa/M\nTherese/M\nTheresina/M\nTheresita/M\nTheressa/M\nTherine/M\nThermos/SM\nTheron/M\nTheseus/M\nThespian/S\nThespis/M\nThessalonian\nThessalonki/M\nThessaly/M\nThia/M\nThibaud/M\nThibaut/M\nThiensville/M\nThieu/M\nThimbu/M\nThimphu\nThom/M\nThoma/SM\nThomasa/M\nThomasin/M\nThomasina/M\nThomasine/M\nThomism/M\nThomistic\nThompson/M\nThomson/M\nThor/M\nThorazine\nThoreau/M\nThorin/M\nThorn/M\nThornburg/M\nThorndike/M\nThornie/M\nThornton/M\nThorny/M\nThorpe/M\nThorstein/M\nThorsten/M\nThorvald/M\nThoth/M\nThrace/M\nThracian/M\nThroneberry/M\nThruway/MS\nThu\nThucydides/M\nThule/M\nThunderbird/M\nThur/MS\nThurber/M\nThurman/M\nThursday/SM\nThurstan/M\nThurston/M\nTi/M\nTia/M\nTianjin\nTiber/M\nTiberius/M\nTibet/M\nTibetan/S\nTibold/M\nTiburon/M\nTiconderoga/M\nTiebold/M\nTiebout/M\nTieck/M\nTiena/M\nTienanmen/M\nTientsin's\nTierney/M\nTiertza/M\nTiff/M\nTiffani/M\nTiffanie/M\nTiffany/M\nTiffi/M\nTiffie/M\nTiffy/M\nTigris/M\nTijuana/M\nTilda/M\nTildi/M\nTildie/M\nTildy/M\nTiler/M\nTillich/M\nTillie/M\nTillman/M\nTilly/M\nTim/MS\nTimbuktu/M\nTimex/M\nTimi/M\nTimmi/M\nTimmie/M\nTimmy/M\nTimofei/M\nTimon/M\nTimoteo/M\nTimothea/M\nTimothee/M\nTimotheus/M\nTimothy/M\nTimur/M\nTina/M\nTine/M\nTing/M\nTinkertoy\nTinseltown/M\nTintoretto/M\nTioga/M\nTiphani/M\nTiphanie/M\nTiphany/M\nTippecanoe/M\nTipperary/M\nTirana's\nTirane\nTiresias/M\nTirol/M\nTirolean/S\nTirrell/M\nTish/M\nTisha/M\nTitan/SM\nTitania/M\nTitanic/M\nTitian/M\nTiticaca/M\nTito/SM\nTitus/M\nTl/M\nTlaloc/M\nTlingit/M\nTm/M\nTobago/M\nTobe/M\nTobey/M\nTobi/M\nTobiah/M\nTobias/M\nTobie/M\nTobin/M\nTobit/M\nToby/M\nTobye/M\nTocantins/M\nTocqueville\nTod/M\nTodd/M\nToddie/M\nToddy/M\nTogo/M\nTogolese/M\nToiboid/M\nToinette/M\nTojo/M\nTokay/M\nTokugawa/M\nTokyo/M\nTokyoite/MS\nToland/M\nToledo/SM\nTolkien\nTolley/M\nTolstoy/M\nTolyatti/M\nTom/M\nToma/SM\nTomasina/M\nTomasine/M\nTomaso/M\nTombaugh/M\nTombigbee/M\nTome/M\nTomi/M\nTomkin/M\nTomlin/M\nTommi/M\nTommie/M\nTommy/M\nTompkins/M\nTomsk/M\nTonga/M\nTongan/SM\nToni/M\nTonia/M\nTonie/M\nTonio/M\nTonnie/M\nTonto/M\nTony/M\nTonya/M\nTonye/M\nToomey/M\nTootsie/M\nTopeka/M\nTopsy/M\nTorah/M\nTorahs\nTore/M\nTorey/M\nTori/M\nTorie/M\nTorin/M\nToronto/M\nTorquemada/M\nTorr/XM\nTorrance/M\nTorre/MS\nTorrence/M\nTorrens/M\nTorrey/M\nTorricelli/M\nTorrie/M\nTorrin/M\nTorry/M\nTortola/M\nTortuga/M\nTory/SM\nTosca/M\nToscanini/M\nToshiba/M\nToto/M\nToulouse/M\nTova/M\nTove/M\nTown/M\nTownes\nTowney/M\nTownie/M\nTownley/M\nTownsend/M\nTowny/M\nTowsley/M\nToynbee/M\nToyoda/M\nToyota/M\nTrace/M\nTracee/M\nTracey/M\nTraci/M\nTracie/M\nTractarians\nTracy/M\nTrafalgar/M\nTrajan/M\nTran/M\nTranscaucasia/M\nTransite/M\nTransputer/M\nTransvaal/M\nTransylvania/M\nTrappist/MS\nTrastevere/M\nTraver/MS\nTravis/M\nTravus/M\nTreadwell/M\nTreasury/SM\nTreblinka/M\nTrefor/M\nTrekkie/M\nTremain/M\nTremaine/M\nTremayne/M\nTrenna/M\nTrent/M\nTrenton/M\nTresa/M\nTrescha/M\nTressa/M\nTrev/RM\nTrevar/M\nTrevelyan/M\nTrever/M\nTrevino/M\nTrevor/M\nTrey/M\nTriangulum/M\nTrianon/M\nTriassic\nTricia/M\nTrieste/M\nTrimble/M\nTrimurti/M\nTrina/M\nTrinidad/M\nTrinity/MS\nTrip/M\nTripoli/M\nTripp/M\nTrippe/M\nTris\nTrish/M\nTrisha/M\nTrista/M\nTristam/M\nTristan/M\nTriton/M\nTrix/M\nTrixi/M\nTrixie/M\nTrixy/M\nTrobriand/M\nTrojan/MS\nTrollope/M\nTrondheim/M\nTropez/M\nTrotsky/M\nTroutman/M\nTroy/M\nTroyes\nTrstram/M\nTruckee/M\nTruda/M\nTrude/M\nTrudeau/M\nTrudey/M\nTrudi/M\nTrudie/M\nTrudy/M\nTrueman/M\nTrujillo/M\nTrula/M\nTrumaine/M\nTruman/M\nTrumann/M\nTrumbull/M\nTrump/M\nTruth\nTsimshian/M\nTsiolkovsky/M\nTsitsihar/M\nTsunematsu/M\nTswana/M\nTuamotu/M\nTuareg/M\nTubman/M\nTuck/RM\nTucker/M\nTuckie/M\nTucky/M\nTucson/M\nTucuman/M\nTudor/MS\nTue/S\nTuesday/SM\nTulane/M\nTull/M\nTulley/M\nTully/M\nTulsa/M\nTums/M\nTungus/M\nTunguska/M\nTunis/M\nTunisia/M\nTunisian/S\nTupi/M\nTupperware\nTupungato/M\nTurgenev/M\nTurin/M\nTuring/M\nTurk/SM\nTurkestan/M\nTurkey/M\nTurkic/SM\nTurkish\nTurkmenistan/M\nTurner/M\nTurpin/M\nTuscaloosa/M\nTuscan\nTuscany/M\nTuscarora/M\nTuscon/M\nTuskegee/M\nTussuad/M\nTut/M\nTutankhamen/M\nTutsi\nTuttle/M\nTuvalu\nTwain/M\nTweed/M\nTweedledee/M\nTweedledum/M\nTwila/M\nTwinkie\nTwp\nTwyla/M\nTy/M\nTybalt/M\nTybi/M\nTybie/M\nTye/M\nTylenol/M\nTyler/M\nTymon/M\nTymothy/M\nTynan/M\nTyndale/M\nTyndall/M\nTyne/M\nTyphon/M\nTyree/M\nTyrol's\nTyrolean/S\nTyrone/M\nTyrus/M\nTyson/M\nTzeltal/M\nU\nUAR\nUART\nUAW\nUCLA/M\nUFO/S\nUHF\nUK\nUL\nULTRIX/M\nUN\nUNESCO\nUNICEF\nUNIX/M\nUPC\nUPI\nUPS\nURL\nUS\nUSA\nUSAF\nUSART\nUSC/M\nUSCG\nUSDA\nUSG/M\nUSIA\nUSMC\nUSN\nUSO\nUSP\nUSPS\nUSS\nUSSR\nUT\nUV\nUbangi/M\nUbuntu\nUbuntu's\nUbuntuOne\nUbuntuOne's\nUcayali/M\nUccello/M\nUdale/M\nUdall/M\nUdell/M\nUfa/M\nUganda/M\nUgandan/S\nUgo/M\nUighur\nUjungpandang/M\nUkraine/M\nUkrainian/S\nUla/M\nUlberto/M\nUlick/M\nUlises/M\nUlla/M\nUllman/M\nUlric/M\nUlrica/M\nUlrich/M\nUlrick/M\nUlrika/M\nUlrikaumeko/M\nUlrike/M\nUlster/M\nUltrasuede\nUltrix/M\nUlyanovsk/M\nUlysses/M\nUmberto/M\nUmbriel/M\nUmeko/M\nUna/M\nUnderwood/M\nUngava/M\nUniPlus/M\nUniSoft/M\nUnibus/M\nUnicode/M\nUnion/MS\nUnionist/SM\nUniroyal/M\nUnisys/M\nUnitarian/MS\nUnitarianism/SM\nUnivac/M\nUnix/M\nUnukalhai/M\nUpanishads\nUpdike/M\nUpton/M\nUr/M\nUral/MS\nUrania/M\nUranus/M\nUrbain/M\nUrban/M\nUrbana/M\nUrbano/M\nUrbanus/M\nUrdu/M\nUrey/M\nUri/SM\nUriah/M\nUriel/M\nUrquhart/M\nUrsa/M\nUrsala/M\nUrsola/M\nUrson/M\nUrsula/M\nUrsulina/M\nUrsuline/M\nUruguay/M\nUruguayan/S\nUrumqi\nUsenet/M\nUsenix/M\nUstinov/M\nUta/M\nUtah/M\nUtahan/SM\nUte/M\nUtica/M\nUtopia/MS\nUtopian/S\nUtrecht/M\nUtrillo/M\nUzbek/M\nUzbekistan\nUzi/M\nV\nV's\nVA\nVAR\nVAT\nVAX/M\nVAXes\nVCR\nVD\nVDT\nVDU\nVF\nVFW\nVG\nVGA\nVHF\nVHS\nVI\nVIP/S\nVISTA\nVJ\nVLF\nVLSI\nVMS/M\nVOA\nVP\nVT\nVTOL\nVa/M\nVachel/M\nVaclav/M\nVader/M\nVaduz/M\nVail/M\nVal/MY\nValaree/M\nValaria/M\nValarie/M\nValdemar/M\nValdez/M\nVale/M\nValeda/M\nValencia/MS\nValene/M\nValenka/M\nValentia/M\nValentijn/M\nValentin/M\nValentina/M\nValentine/M\nValentino/M\nValenzuela/M\nValera/M\nValeria/M\nValerian/M\nValerie/M\nValerye/M\nValhalla/M\nValida/M\nValina/M\nValium/S\nValkyrie/SM\nValle/M\nVallejo\nValletta/M\nValli/M\nVallie/M\nVally/M\nValma/M\nValois/M\nValparaiso/M\nValry/M\nValry/M\nVan/M\nVance/M\nVancouver/M\nVanda/M\nVandal/MS\nVandenberg/M\nVanderbilt/M\nVanderburgh/M\nVanderpoel/M\nVandyke/SM\nVanessa/M\nVang/M\nVania/M\nVanna/M\nVanni/M\nVannie/M\nVanny/M\nVanuatu\nVanya/M\nVanzetti/M\nVaranasi/M\nVarese/M\nVargas/M\nVarian/M\nVarityping/M\nVaseline/DSMG\nVasili/MS\nVasily/M\nVasquez/M\nVassar/M\nVassili/M\nVassily/M\nVatican/M\nVaudois\nVaughan/M\nVaughn/M\nVax/M\nVazquez/M\nVeblen/M\nVeda/MS\nVedanta/M\nVega/SM\nVegemite/M\nVela/M\nVelcro/SM\nVelez/M\nVella/M\nVelma/M\nVelveeta/M\nVelvet/M\nVelsquez/M\nVelzquez\nVenetian/SM\nVenezuela/M\nVenezuelan/S\nVenice/M\nVenita/M\nVenn/M\nVentura/M\nVenus/S\nVenusian/S\nVera/M\nVeracruz/M\nVeradis\nVerde/M\nVerderer/M\nVerdi/M\nVere/M\nVerena/M\nVerene/M\nVerge/M\nVergil's\nVeriee/M\nVerile/M\nVerina/M\nVerine/M\nVerla/M\nVerlag/M\nVerlaine/M\nVermeer/M\nVermont/ZRM\nVermonter/M\nVern/NM\nVerna/M\nVerne/M\nVernen/M\nVerney/M\nVernice/M\nVernon/M\nVernor/M\nVerona/M\nVeronese/M\nVeronica/M\nVeronika/M\nVeronike/M\nVeronique/M\nVersailles/M\nVersatec/M\nVesalius/M\nVespasian/M\nVespucci/M\nVesta/M\nVesuvius/M\nVevay/M\nVi/M\nViagra/M\nVic/M\nVicente/M\nVichy/M\nVick/ZM\nVickers/M\nVicki/M\nVickie/M\nVicksburg/M\nVicky/M\nVictoir/M\nVictor/M\nVictoria/M\nVictorian/S\nVictorianism/S\nVictrola/SM\nVida/M\nVidal/M\nVidovic/M\nVidovik/M\nVienna/M\nViennese/M\nVientiane/M\nViet/M\nVietcong/M\nVietminh/M\nVietnam/M\nVietnamese/M\nVijayawada/M\nViki/M\nViking/MS\nVikki/M\nVikky/M\nVikram/M\nVila\nVilhelmina/M\nVilla/M\nVillarreal/M\nVillon/M\nVilma/M\nVilnius/M\nVilyui/M\nVin/M\nVina/M\nVince/M\nVincent/MS\nVincenty/M\nVincenz/M\nVinci/M\nVindemiatrix/M\nVinita/M\nVinni/M\nVinnie/M\nVinny/M\nVinson/M\nViola/M\nViolante/M\nViole/M\nViolet/M\nVioletta/M\nViolette/M\nVirge/M\nVirgie/M\nVirgil/M\nVirgilio/M\nVirgina/M\nVirginia/M\nVirginian/S\nVirginie/M\nVirgo/MS\nVisa/M\nVisakhapatnam's\nVisayans\nVishnu/M\nVisigoth/M\nVisigoths\nVistula/M\nVita/M\nVite/M\nVitia/M\nVitim/M\nVito/M\nVitoria/M\nVittoria/M\nVittorio/M\nVitus/M\nViv/M\nViva/M\nVivaldi\nVivekananda/M\nVivi/MN\nVivia/M\nVivian/M\nViviana/M\nVivianna/M\nVivianne/M\nVivie/M\nVivien/M\nViviene/M\nVivienne/M\nViviyan/M\nVivyan/M\nVivyanne/M\nVlad/M\nVladamir/M\nVladimir/M\nVladivostok/M\nVogel/M\nVol/M\nVolga/M\nVolgograd/M\nVolkswagen/SM\nVolstead/M\nVolta/M\nVoltaire/M\nVolterra/M\nVolvo/M\nVon/M\nVonda/M\nVonnegut/M\nVonni/M\nVonnie/M\nVonny/M\nVoronezh/M\nVorster/M\nVt/M\nVulcan/M\nVulg/M\nVulgate/SM\nVyky/M\nW's\nW/T\nWA\nWAC\nWASP\nWATS\nWC\nWFF\nWHO\nWI\nWNW\nWP\nWSW\nWV\nWW\nWWI\nWWII\nWWW\nWY\nWYSIWYG\nWaals\nWabash/M\nWac/S\nWacke/M\nWaco/M\nWade/M\nWadsworth/M\nWafs\nWagner/M\nWagnerian\nWahl/M\nWaikiki/M\nWain/M\nWainwright/M\nWait/MR\nWaite/M\nWaiter/M\nWake/M\nWakefield/M\nWaksman/M\nWalbridge/M\nWalcott/M\nWald/MN\nWaldemar/M\nWalden/M\nWaldensian\nWaldheim/M\nWaldo/M\nWaldon/M\nWaldorf/M\nWales\nWalesa/M\nWalford/M\nWalgreen/M\nWalker/M\nWalkman/S\nWall/SMR\nWallace/M\nWallache/M\nWallas/M\nWallenstein/M\nWaller/M\nWallie/M\nWallis\nWalliw/M\nWalloon/SM\nWally/M\nWalpole/M\nWalpurgisnacht\nWalsh/M\nWalt/ZMR\nWalter/M\nWalther/M\nWalton/M\nWalworth/M\nWaly/M\nWanamaker/M\nWanda/M\nWandie/M\nWandis/M\nWaneta/M\nWang/M\nWanids/M\nWankel/M\nWansee/M\nWansley/M\nWard/MN\nWarde/M\nWarden/M\nWare/MG\nWarfield/M\nWarhol/M\nWaring/M\nWarner/M\nWarnock/M\nWarren/M\nWarsaw/M\nWarwick/M\nWasatch/M\nWash/M\nWashburn/M\nWashington/M\nWashingtonian/S\nWashoe/M\nWasp's\nWasserman/M\nWassermann/M\nWat/ZM\nWatanabe/M\nWaterbury/M\nWatergate/M\nWaterhouse/M\nWaterloo/SM\nWaters/M\nWatertown/M\nWatkins\nWatson/M\nWatt/MS\nWatteau/M\nWattenberg/M\nWatterson/M\nWatusi/M\nWaugh/M\nWaukesha/M\nWaunona/M\nWaupaca/M\nWaupun/M\nWausau/M\nWauwatosa/M\nWave/S\nWaveland/M\nWaverley/M\nWaverly/M\nWay/M\nWaylan/M\nWayland/M\nWaylen/M\nWaylin/M\nWaylon/M\nWayne/M\nWaynesboro/M\nWeatherford/M\nWeaver/M\nWeb/MR\nWebb/RM\nWebber/M\nWeber/M\nWebern/M\nWebster/MS\nWebsterville/M\nWed/M\nWeddell/M\nWedgwood/M\nWednesday/SM\nWeeks/M\nWehr/M\nWei/M\nWeibull/M\nWeidar/M\nWeider/M\nWeidman/M\nWeierstrass/M\nWeill/M\nWeinberg/M\nWeiner/M\nWeinstein/M\nWeisenheimer/M\nWeiss/M\nWeissman/M\nWeissmuller/M\nWeizmann/M\nWelbie/M\nWelby/M\nWelcher/M\nWelches\nWeldon/M\nWeldwood/M\nWelland/M\nWeller/M\nWelles/M\nWellesley/M\nWellington/MS\nWellman/M\nWells/M\nWellsville/M\nWelmers/M\nWelsh\nWelshman/M\nWelshmen\nWelshwoman/M\nWelshwomen\nWenda/M\nWendall/M\nWendel/M\nWendeline/M\nWendell/M\nWendi/M\nWendie/M\nWendy/M\nWendye/M\nWenona/M\nWenonah/M\nWentworth/M\nWerner/M\nWernher/M\nWerther/M\nWes\nWesley/M\nWesleyan\nWessex/M\nWesson/M\nWest/MS\nWestbrook/M\nWestbrooke/M\nWestchester/M\nWestern/ZRS\nWestfield/M\nWesthampton/M\nWestinghouse/M\nWestleigh/M\nWestley/M\nWestminster/M\nWestmore/M\nWeston/M\nWestphalia/M\nWestport/M\nWestwood/M\nWeyden/M\nWeyerhauser/M\nWeylin/M\nWezen/M\nWhalen/M\nWharton/M\nWheaties/M\nWheatland/M\nWheaton/M\nWheatstone/M\nWheeler/M\nWheeling/M\nWheelock/M\nWhelan/M\nWheller/M\nWhig/SM\nWhippany/M\nWhipple/M\nWhistler/M\nWhit/M\nWhitaker/M\nWhitby/M\nWhitcomb/M\nWhite/MS\nWhitefield/M\nWhitehall/M\nWhitehead/M\nWhitehorse/M\nWhiteleaf/M\nWhiteley/M\nWhitewater/M\nWhitfield/M\nWhitley/M\nWhitlock/M\nWhitman/M\nWhitney/M\nWhitsunday/MS\nWhittaker/M\nWhittier\nWiatt/M\nWichita/M\nWieland/M\nWiemar/M\nWier/M\nWiesel/M\nWiggins\nWigner/M\nWilberforce/M\nWilbert/M\nWilbur/M\nWilburn/M\nWilburt/M\nWilcox/M\nWilda/M\nWilde/MR\nWilden/M\nWilder/M\nWildon/M\nWileen/M\nWilek/M\nWiley/M\nWilford/M\nWilfred/M\nWilfredo/M\nWilfrid/M\nWilhelm/M\nWilhelmina/M\nWilhelmine/M\nWilie/M\nWilkerson/M\nWilkes/M\nWilkins/M\nWilkinson/M\nWill/M\nWilla/M\nWillabella/M\nWillamette/M\nWillamina/M\nWillard/M\nWillcox/M\nWilldon/M\nWillem/M\nWillemstad/M\nWilletta/M\nWillette/M\nWilley/M\nWilli/MS\nWilliam/SM\nWilliamsburg/M\nWilliamson/M\nWillie/M\nWillied/M\nWillisson/M\nWilloughby/M\nWillow/M\nWilly/SDM\nWillyt/M\nWilma/M\nWilmar/M\nWilmer/M\nWilmette/M\nWilmington/M\nWilona/M\nWilone/M\nWilow/M\nWilshire/M\nWilson/M\nWilsonian\nWilt/M\nWilton/M\nWimbledon/M\nWin/M\nWinchell/M\nWinchester/MS\nWindham/M\nWindhoek/M\nWindows\nWindsor/MS\nWindward/M\nWindy/M\nWinehead/M\nWinesap/M\nWinfield/M\nWinfred/M\nWinfrey/M\nWini/M\nWinifield/M\nWinifred/M\nWinkle/M\nWinn/M\nWinna/M\nWinnah/M\nWinne/M\nWinnebago/M\nWinnetka/M\nWinni/M\nWinnie/M\nWinnifred/M\nWinnipeg/M\nWinny/M\nWinograd/M\nWinona/M\nWinonah/M\nWinooski/M\nWinsborough/M\nWinsett/M\nWinslow/M\nWinston/M\nWinters\nWinthrop/M\nWis/M\nWisc\nWisconsin/M\nWisconsinite/SM\nWise/M\nWisenheimer/M\nWit/M\nWitherspoon/M\nWitt/M\nWittgenstein/M\nWittie/M\nWitty/M\nWitwatersrand/M\nWm/M\nWodehouse/M\nWolcott/M\nWolf/M\nWolfe/M\nWolff/M\nWolfgang/M\nWolfie/M\nWolfy/M\nWollongong/M\nWollstonecraft/M\nWolsey/M\nWolverhampton/M\nWolverton/M\nWong/M\nWood/SM\nWoodard/M\nWoodberry/M\nWoodbury/M\nWoodhull/M\nWoodie/M\nWoodlawn/M\nWoodman/M\nWoodrow/M\nWoodstock/M\nWoodward/MS\nWoody/M\nWoolf/M\nWoolongong/M\nWoolworth/M\nWoonsocket/M\nWooster/M\nWooten/M\nWorcester/SM\nWorcestershire/M\nWorden/M\nWordsworth/M\nWorkman/M\nWorms/M\nWorth/M\nWorthington/M\nWorthy/M\nWotan/M\nWozniak/M\nWrangell/M\nWren/MS\nWrennie/M\nWright/M\nWrigley/M\nWroclaw\nWronskian/M\nWu/M\nWuhan/M\nWurlitzer/M\nWyatan/M\nWyatt/M\nWycherley/M\nWycliffe/M\nWye/MH\nWyeth/M\nWylie/M\nWylma/M\nWyman/M\nWyn/M\nWyndham/M\nWynn/M\nWynne/M\nWynnie/M\nWynny/M\nWyo/M\nWyoming/M\nWyomingite/SM\nX\nX's\nXEmacs/M\nXL\nXML\nXOR\nXS\nXXL\nXanadu\nXanthippe/M\nXanthus/M\nXavier/M\nXaviera/M\nXe/M\nXebec/M\nXena/M\nXenakis/M\nXenia/M\nXenix/M\nXenophon/M\nXenos\nXerox/MGSD\nXerxes/M\nXever/M\nXhosa/M\nXi'an\nXian/S\nXiaoping/M\nXimenes/M\nXimenez/M\nXimian/SM\nXingu/M\nXmas/SM\nXochipilli/M\nXuzhou/M\nXylia/M\nXylina/M\nXymenes/M\nY\nY's\nYMCA\nYMHA\nYMMV\nYT\nYWCA\nYWHA\nYacc/M\nYagi/M\nYahweh/M\nYakima/M\nYakut/M\nYakutsk/M\nYale/M\nYalies/M\nYalonda/M\nYalow/M\nYalta/M\nYalu/M\nYamaha/M\nYamoussoukro\nYanaton/M\nYance/M\nYancey/M\nYancy/M\nYang/M\nYangon\nYangtze/M\nYank/MS\nYankee/SM\nYaounde/M\nYaqui/M\nYard/M\nYardley/M\nYaroslavl/M\nYasmeen/M\nYasmin/M\nYates\nYb/M\nYeager/M\nYeats/M\nYehudi/M\nYehudit/M\nYekaterinburg/M\nYelena/M\nYellowknife/M\nYellowstone/M\nYeltsin\nYemen/M\nYemeni/S\nYemenite/SM\nYenisei/M\nYentl/M\nYerevan/M\nYerkes/M\nYesenia/M\nYetta/M\nYettie/M\nYetty/M\nYevette/M\nYevtushenko/M\nYggdrasil/M\nYiddish/M\nYmir/M\nYnes/M\nYnez/M\nYoda/M\nYoder/M\nYoknapatawpha/M\nYoko/M\nYokohama/M\nYolanda/M\nYolande/M\nYolane/M\nYolanthe/M\nYong/M\nYonkers/M\nYorgo/MS\nYorick/M\nYork/ZRMS\nYorke/M\nYorker/M\nYorkshire/MS\nYorktown/M\nYoruba/M\nYosemite/M\nYoshi/M\nYoshiko/M\nYost/M\nYoung/M\nYoungstown/M\nYovonnda/M\nYpres/M\nYpsilanti/M\nYsabel/M\nYuba/M\nYucatan\nYugo/M\nYugoslav/M\nYugoslavia/M\nYugoslavian/S\nYuh/M\nYuki/M\nYukon/M\nYul/M\nYule/MS\nYuletide/S\nYulma/M\nYuma/M\nYunnan/M\nYuri/M\nYurik/M\nYves/M\nYvette/M\nYvon/M\nYvonne/M\nYvor/M\nZ/X\nZabrina/M\nZaccaria/M\nZach/M\nZacharia/SM\nZachariah/M\nZacharie/M\nZachary/M\nZacherie/M\nZachery/M\nZack/M\nZackariah/M\nZagreb/M\nZahara/M\nZaire/M\nZairian/S\nZak/M\nZambezi/M\nZambia/M\nZambian/S\nZamboni\nZamenhof/M\nZamora/M\nZan/M\nZandra/M\nZane/M\nZaneta/M\nZanuck/M\nZanzibar/M\nZapata/M\nZaporozhye/M\nZappa/M\nZara/M\nZarah/M\nZared/M\nZaria/M\nZarla/M\nZea/M\nZealand/M\nZeb/M\nZebadiah/M\nZebedee/M\nZebulen/M\nZebulon/M\nZechariah/M\nZed/M\nZedekiah/M\nZedong/M\nZeffirelli/M\nZeiss/M\nZeke/M\nZelda/M\nZelig/M\nZellerbach/M\nZelma/M\nZen/M\nZena/M\nZenger/M\nZenia/M\nZennist/M\nZeno/M\nZephaniah/M\nZephyrus/M\nZeppelin's\nZerk/M\nZeus/M\nZhdanov/M\nZhengzhou\nZhivago/M\nZhukov/M\nZia/M\nZibo/M\nZiegfeld/MS\nZiegler/M\nZiggy/M\nZilvia/M\nZimbabwe/M\nZimbabwean/S\nZimmerman/M\nZion/SM\nZionism/MS\nZionist/MS\nZita/M\nZitella/M\nZn/M\nZoe/M\nZola/M\nZollie/M\nZolly/M\nZomba/M\nZonda/M\nZondra/M\nZonnya/M\nZora/M\nZorah/M\nZorana/M\nZorina/M\nZorine/M\nZorn/M\nZoroaster/M\nZoroastrian/S\nZoroastrianism/MS\nZorro/M\nZosma/M\nZr/M\nZs\nZsazsa/M\nZsigmondy/M\nZubenelgenubi/M\nZubeneschamali/M\nZukor/M\nZulema/M\nZulu/MS\nZululand/M\nZuni/S\nZuzana/M\nZwingli/M\nZworykin/M\nZrich/M\na\naardvark/SM\nab/DY\naback\nabacus/SM\nabaft\nabalone/SM\nabandon/LGDRS\nabandoner/M\nabandonment/SM\nabase/LGDSR\nabasement/S\nabaser/M\nabash/SDLG\nabashed/UY\nabashment/MS\nabate/DSRLG\nabated/U\nabatement/MS\nabater/M\nabattoir/SM\nabbess/SM\nabbey/MS\nabbot/MS\nabbr\nabbrev\nabbreviate/XDSNG\nabbreviated/UA\nabbreviates/A\nabbreviating/A\nabbreviation/M\nabb/S\nabdicate/NGDSX\nabdication/M\nabdomen/SM\nabdominal/YS\nabduct/DGS\nabduction/SM\nabductor/SM\nabeam\naberrant/YS\naberration/SM\naberrational\nabet/S\nabetted\nabetting\nabettor/SM\nabeyance/MS\nabeyant\nabhor/S\nabhorred\nabhorrence/MS\nabhorrent/Y\nabhorrer/M\nabhorring\nabidance/MS\nabide/JGSR\nabider/M\nabiding/Y\nability/IMES\nabject/SGPDY\nabjection/MS\nabjectness/SM\nabjuration/SM\nabjuratory\nabjure/ZGSRD\nabjurer/M\nablate/VGNSDX\nablation/M\nablative/SY\nablaze\nable/U\nabler/E\nables/E\nablest\nabloom\nablution/MS\nabnegate/NGSDX\nabnegation/M\nabnormal/SY\nabnormality/SM\naboard\nabode/GMDS\nabolish/LZRSDG\nabolisher/M\nabolishment/MS\nabolition/SM\nabolitionism/SM\nabolitionist/SM\nabominable\nabominably\nabominate/XSDGN\nabomination/M\naboriginal/YS\naborigine/SM\naborning\nabort/SRDVG\nabortion/MS\nabortionist/MS\nabortive/PY\nabortiveness/M\nabound/GDS\nabout/S\nabove/S\naboveboard\naboveground\nabracadabra/S\nabrade/SRDG\nabrader/M\nabrasion/MS\nabrasive/SYMP\nabrasiveness/S\nabreaction/MS\nabreast\nabridge/DSRG\nabridged/U\nabridger/M\nabridgment/SM\nabroad\nabrogate/XDSNG\nabrogation/M\nabrogator/SM\nabrupt/TRYP\nabruptness/SM\nabs/M\nabscess/GDSM\nabscissa/SM\nabscission/SM\nabscond/SDRZG\nabsconder/M\nabseil/SGDR\nabsence/SM\nabsent/SGDRY\nabsentee/MS\nabsenteeism/SM\nabsentia/M\nabsentminded/PY\nabsentmindedness/S\nabsinthe/SM\nabsolute/NPRSYTX\nabsoluteness/SM\nabsolution/M\nabsolutism/MS\nabsolutist/SM\nabsolve/GDSR\nabsolver/M\nabsorb/ASGD\nabsorbed/U\nabsorbency/MS\nabsorbent/MS\nabsorber/SM\nabsorbing/Y\nabsorption/MS\nabsorptive\nabsorptivity/M\nabstain/GSDRZ\nabstainer/M\nabstemious/YP\nabstemiousness/MS\nabstention/SM\nabstinence/MS\nabstinent/Y\nabstract/PTVGRDYS\nabstracted/YP\nabstractedness/SM\nabstracter/M\nabstraction/SM\nabstractionism/M\nabstractionist/SM\nabstractness/SM\nabstractor/MS\nabstruse/PRYT\nabstruseness/SM\nabsurd/PRYST\nabsurdity/SM\nabsurdness/SM\nabundance/SM\nabundant/Y\nabuse/GVZDSRB\nabused/E\nabuser/M\nabuses/E\nabusing/E\nabusive/YP\nabusiveness/SM\nabut/LS\nabutment/SM\nabutted\nabutter/MS\nabutting\nabuzz\nabysmal/Y\nabyss/SM\nabyssal\nac/DRG\nacacia/SM\nacademe/MS\nacademia/SM\nacademic/S\nacademical/Y\nacademician/SM\nacademicianship\nacademy/SM\nacanthus/MS\naccede/SDG\naccelerate/NGSDXV\naccelerated/U\naccelerating/Y\nacceleration/M\naccelerator/SM\naccelerometer/SM\naccent/SGMD\naccented/U\naccentual/Y\naccentuate/XNGSD\naccentuation/M\naccept/RDBSZVG\nacceptability's/U\nacceptability/SM\nacceptable/P\nacceptableness/SM\nacceptably/U\nacceptance/SM\nacceptant\nacceptation/SM\naccepted/Y\naccepter/M\naccepting/PY\nacceptor/MS\naccess/SDMG\naccessed/A\naccessibility/IMS\naccessible/IU\naccessibly/I\naccession/SMDG\naccessors\naccessory/SM\naccidence/M\naccident/MS\naccidental/SPY\naccidentalness/M\nacclaim/SDRG\nacclaimer/M\nacclamation/MS\nacclimate/XSDGN\nacclimation/M\nacclimatisation\nacclimatise/DG\nacclimatization/AMS\nacclimatize/RSDGZ\nacclimatized/U\nacclimatizes/A\nacclivity/SM\naccolade/GDSM\naccommodate/XVNGSD\naccommodated/U\naccommodating/Y\naccommodation/M\naccommodative/P\naccommodativeness/M\naccompanied/U\naccompanier/M\naccompaniment/MS\naccompanist/SM\naccompany/DRSG\naccomplice/MS\naccomplish/SRDLZG\naccomplished/U\naccomplisher/M\naccomplishment/SM\naccord/SZGMRD\naccordance/SM\naccordant/Y\naccorder/M\naccording/Y\naccordion/MS\naccordionist/SM\naccost/SGD\naccount/BMDSGJ\naccountability's/U\naccountability/MS\naccountable/U\naccountableness/M\naccountably/U\naccountancy/SM\naccountant/MS\naccounted/U\naccounting/M\naccouter/GSD\naccouterment's\naccouterments\naccoutrement/M\naccredit/SGD\naccreditation/SM\naccredited/U\naccretion/SM\naccrual/MS\naccrue/SDG\nacct\nacculturate/XSDVNG\nacculturation/M\naccumulate/VNGSDX\naccumulation/M\naccumulative/YP\naccumulativeness/M\naccumulator/MS\naccuracy/IMS\naccurate/IY\naccurateness/SM\naccursed/YP\naccursedness/SM\naccusal/M\naccusation/SM\naccusative/S\naccusatory\naccuse/SRDZG\naccused/M\naccuser/M\naccusing/Y\naccustom/SGD\naccustomed/P\naccustomedness/M\nace/SM\naced/M\nacerbate/DSG\nacerbic\nacerbically\nacerbity/MS\nacetaminophen/S\nacetate/MS\nacetic\nacetone/SM\nacetonic\nacetylene/MS\nache/DSG\nached/A\nachene/SM\naches/A\nachievable/U\nachieve/LZGRSDB\nachieved/UA\nachievement/SM\nachiever/M\naching/Y\nachoo\nachromatic\nachy/TR\nacid/SMYP\nacidic\nacidification/M\nacidify/NSDG\nacidity/SM\nacidness/M\nacidoses\nacidosis/M\nacidulous\nacing/M\nacknowledge/GZDRS\nacknowledgeable\nacknowledged/U\nacknowledgedly\nacknowledgement/SAM\nacknowledger/M\nacknowledgment/SAM\nacme/SM\nacne/MDS\nacolyte/MS\naconite/MS\nacorn/SM\nacoustic/S\nacoustical/Y\nacoustician/M\nacoustics/M\nacquaint/GASD\nacquaintance/MS\nacquaintanceship/S\nacquainted/U\nacquiesce/GSD\nacquiescence/SM\nacquiescent/Y\nacquirable\nacquire/ASDG\nacquirement/SM\nacquisition's/A\nacquisition/SM\nacquisitive/PY\nacquisitiveness/MS\nacquit/S\nacquittal/MS\nacquittance/M\nacquitted\nacquitter/M\nacquitting\nacre/MS\nacreage/MS\nacrid/TPRY\nacridity/MS\nacridness/SM\nacrimonious/YP\nacrimoniousness/MS\nacrimony/MS\nacrobat/SM\nacrobatic/S\nacrobatically\nacrobatics/M\nacronym/SM\nacrophobia/SM\nacropolis/SM\nacross\nacrostic/SM\nacrylate/M\nacrylic/S\nact's\nact/SADVG\nacting/S\nactinic\nactinide/SM\nactinium/MS\nactinometer/MS\naction's/IA\naction/DMSGB\nactions/AI\nactivate/AXCDSNGI\nactivated/U\nactivation/AMCI\nactivator/SM\nactive/APY\nactively/I\nactiveness/MS\nactives\nactivism/MS\nactivist/MS\nactivities/A\nactivity/MSI\nactor/MAS\nactress/SM\nactual/SY\nactuality/SM\nactualization/MAS\nactualize/GSD\nactualizes/A\nactuarial/Y\nactuary/MS\nactuate/GNXSD\nactuation/M\nactuator/SM\nacuity/MS\nacumen/SM\nacupressure/S\nacupuncture/SM\nacupuncturist/S\nacute/YTSRP\nacuteness/MS\nacyclic\nacyclically\nacyclovir/S\nad's\nad/AS\nadage/MS\nadagio/S\nadamant/SY\nadapt/SRDBZVG\nadaptability/MS\nadaptable/U\nadaptation/MS\nadapted/P\nadaptedness/M\nadapter/M\nadapting/A\nadaption\nadaptive/U\nadaptively\nadaptiveness/M\nadaptivity\nadd/ZGBSDR\naddend/SM\naddenda\naddendum/M\nadder/M\naddict/SGVD\naddiction/MS\naddictive/P\naddition/MS\nadditional/Y\nadditive/YMS\nadditivity\naddle/GDS\naddress/MDRSZGB\naddressability\naddressable/U\naddressed/A\naddressee/SM\naddresser/M\naddresses/A\nadduce/GRSD\nadducer/M\nadduct/DGVS\nadduction/M\nadductor/M\nadenine/SM\nadenoid/S\nadenoidal\nadept/RYPTS\nadeptness/MS\nadequacy/IMS\nadequate/IPY\nadequateness's/I\nadequateness/SM\nadhere/ZGRSD\nadherence/SM\nadherent/YMS\nadherer/M\nadhesion/MS\nadhesive/PYMS\nadhesiveness/MS\nadiabatic\nadiabatically\nadieu/S\nadipose/S\nadis\nadj\nadjacency/MS\nadjacent/Y\nadjectival/Y\nadjective/MYS\nadjoin/SDG\nadjoint/M\nadjourn/DGLS\nadjournment/SM\nadjudge/DSG\nadjudicate/VNGXSD\nadjudication/M\nadjudicator/SM\nadjudicatory\nadjunct/VSYM\nadjuration/SM\nadjure/GSD\nadjust/DRALGSB\nadjustable/U\nadjustably\nadjusted/U\nadjuster's/A\nadjuster/SM\nadjustive\nadjustment/MAS\nadjustor's\nadjutant/SM\nadman/M\nadmen\nadminister/GDJS\nadministrable\nadministrate/XSDVNG\nadministration/M\nadministrative/Y\nadministrator/MS\nadministratrix/M\nadmirable/P\nadmirableness/M\nadmirably\nadmiral/SM\nadmiralty/MS\nadmiration/MS\nadmire/RSDZBG\nadmirer/M\nadmiring/Y\nadmissibility/ISM\nadmissible/I\nadmissibly\nadmission/AMS\nadmit/AS\nadmittance/MS\nadmitted/A\nadmittedly\nadmitting/A\nadmix/SDG\nadmixture/SM\nadmonish/GLSRD\nadmonisher/M\nadmonishing/Y\nadmonishment/SM\nadmonition/MS\nadmonitory\nado/MS\nadobe/MS\nadolescence/MS\nadolescent/SYM\nadopt/RDSBZVG\nadopted/AU\nadopter/M\nadoption/MS\nadoptive/Y\nadopts/A\nadorable/P\nadorableness/SM\nadorably\nadoration/SM\nadore/DSRGZB\nadorer/M\nadoring/Y\nadorn/SGLD\nadorned/U\nadornment/SM\nadrenal/YS\nadrenalin\nadrenaline/MS\nadrift\nadroit/RTYP\nadroitness/MS\nads\nadsorb/GSD\nadsorbate/M\nadsorbent/S\nadsorption/MS\nadsorptive/Y\nadulate/GNDSX\nadulation/M\nadulator/SM\nadulatory\nadult/MYPS\nadulterant/SM\nadulterate/NGSDX\nadulterated/U\nadulteration/M\nadulterer/SM\nadulteress/MS\nadulterous/Y\nadultery/SM\nadulthood/MS\nadultness/M\nadumbrate/XSDVGN\nadumbration/M\nadumbrative/Y\nadv\nadvance/DSRLZG\nadvancement/MS\nadvancer/M\nadvantage/GMEDS\nadvantageous/EY\nadvantageousness/M\nadvent/SVM\nadventist/S\nadventitious/PY\nadventitiousness/M\nadventive/Y\nadventure/SRDGMZ\nadventurer/M\nadventuresome\nadventuress/SM\nadventurous/YP\nadventurousness/SM\nadverb/SM\nadverbial/MYS\nadversarial\nadversary/SM\nadverse/DSRPYTG\nadverseness/MS\nadversity/SM\nadvert/GSD\nadvertise/JGZSRDL\nadvertised/U\nadvertisement/SM\nadvertiser/M\nadvertising/M\nadvertorial/S\nadvice/SM\nadvisability/SIM\nadvisable/I\nadvisableness/M\nadvisably\nadvise/ZRSDGLB\nadvised/YU\nadvisedly/I\nadvisee/MS\nadvisement/MS\nadviser/M\nadvisor's\nadvisor/S\nadvisory/S\nadvocacy/SM\nadvocate/NGVDS\nadvocation/M\nadvt\nadz/MDSG\nadze's\naegis/SM\naeolian\naeon's\naerate/XNGSD\naeration/M\naerator/MS\naerial/SMY\naerialist/MS\naerie/SRMT\naeroacoustic\naerobatic/S\naerobic/S\naerobically\naerodrome/SM\naerodynamic/S\naerodynamically\naerodynamics/M\naeronautic/S\naeronautical/Y\naeronautics/M\naerosol/MS\naerosolize/D\naerospace/SM\naesthete/S\naesthetic/U\naesthetically\naestheticism/MS\naesthetics/M\naether/M\naetiology/M\nafar/S\naffability/MS\naffable/TR\naffably\naffair/SM\naffect/EGSD\naffectation/MS\naffected/UEYP\naffectedness/EM\naffecter/M\naffecting/Y\naffection/EMS\naffectionate/UY\naffectioned\naffectioning\naffective/MY\nafferent/YS\naffiance/GDS\naffidavit/SM\naffiliate/EXSDNG\naffiliated/U\naffiliation/EM\naffine\naffinity/SM\naffirm/ASDG\naffirmation/SAM\naffirmative/SY\naffix/SDG\nafflatus/MS\nafflict/GVDS\naffliction/SM\nafflictive/Y\naffluence/SM\naffluent/YS\nafford/DSBG\nafforest/A\nafforestation/SM\nafforested\nafforesting\nafforests\naffray/MDSG\naffricate/VNMS\naffrication/M\naffricative/M\naffright\naffront/GSDM\nafghan/MS\naficionado/MS\nafield\nafire\naflame\nafloat\naflutter\nafoot\nafore\naforementioned\naforesaid\naforethought/S\nafoul\nafraid/U\nafresh\nafro\naft/ZR\nafterbirth/M\nafterbirths\nafterburner/MS\naftercare/SM\naftereffect/MS\nafterglow/MS\nafterimage/MS\nafterlife/M\nafterlives\naftermath/M\naftermaths\naftermost\nafternoon/SM\nafters/M\naftershave/S\naftershock/SM\naftertaste/SM\nafterthought/MS\nafterward/S\nafterworld/MS\nagain\nagainst\nagapae\nagape/S\nagar/MS\nagate/SM\nagave/SM\nage/GJDRSMZ\naged/PY\nagedness/M\nageism/S\nageist/S\nageless/YP\nagelessness/MS\nagency/SM\nagenda/MS\nagent/AMS\nagented\nagenting\nagentive\nageratum/M\nagglomerate/XNGVDS\nagglomeration/M\nagglutinate/VNGXSD\nagglutination/M\nagglutinin/MS\naggrandize/LDSG\naggrandizement/SM\naggravate/SDNGX\naggravating/Y\naggravation/M\naggregate/EGNVD\naggregated/U\naggregately\naggregateness/M\naggregates\naggregation/SM\naggregative/Y\naggression/SM\naggressive/U\naggressively\naggressiveness/S\naggressor/MS\naggrieve/GDS\naggrieved/Y\naghast\nagile/YTR\nagility/MS\nagitate/XVNGSD\nagitated/Y\nagitation/M\nagitator/SM\nagitprop/MS\nagleam\naglitter\naglow\nagnostic/SM\nagnosticism/MS\nago\nagog\nagonize/ZGRSD\nagonized/Y\nagonizedly/S\nagonizing/Y\nagony/SM\nagoraphobia/MS\nagoraphobic/S\nagrarian/S\nagrarianism/MS\nagree/LEBDS\nagreeable/EP\nagreeableness/SME\nagreeably/E\nagreeing/E\nagreement/ESM\nagreer/S\nagribusiness/SM\nagricultural/Y\nagriculturalist/S\nagriculture/MS\nagriculturist/SM\nagrochemicals\nagronomic/S\nagronomist/SM\nagronomy/MS\naground\nague/MS\nah\naha/S\nahead\nahem/S\nahoy/S\naid/ZGDRS\naide/MS\naided/U\naider/M\naigrette/SM\nail/LSDG\naileron/MS\nailment/SM\naim/ZSGDR\naimer/M\naimless/YP\naimlessness/MS\nain't\nair/MDRTZGJS\nairbag/MS\nairbase/S\nairborne\nairbrush/SDMG\nairbus/SM\naircraft/MS\naircrew/M\nairdrop/MS\nairdropped\nairdropping\nairfare/S\nairfield/MS\nairflow/SM\nairfoil/MS\nairframe/MS\nairfreight/SGD\nairhead/MS\nairily\nairiness/MS\nairing/M\nairless/P\nairlessness/S\nairlift/MDSG\nairline/SRMZ\nairliner/M\nairlock/MS\nairmail/DSG\nairman/M\nairmass\nairmen\nairpark\nairplane/SM\nairplay/S\nairport/MS\nairship/MS\nairsick/P\nairsickness/SM\nairspace/SM\nairspeed/SM\nairstrip/MS\nairtight/P\nairtightness/M\nairtime\nairwaves\nairway/SM\nairworthiness/SM\nairworthy/PTR\nairy/PRT\naisle/DSGM\naitch/MS\najar\naka\nakimbo\nakin\nala/MS\nalabaster/MS\nalack/S\nalacrity/SM\nalanine/M\nalarm/SDG\nalarming/Y\nalarmist/MS\nalas/S\nalb/MS\nalba/M\nalbacore/SM\nalbatross/SM\nalbedo/M\nalbeit\nalbinism/SM\nalbino/MS\nalbum/MNXS\nalbumen/M\nalbumin/MS\nalbuminous\nalchemical\nalchemist/SM\nalchemy/MS\nalcohol/MS\nalcoholic/MS\nalcoholically\nalcoholism/SM\nalcove/MSD\naldehyde/M\nalder/SM\nalderman/M\naldermen\nalderwoman\nalderwomen\nale/MVS\naleatory\nalee\nalehouse/MS\nalembic/SM\naleph/M\nalert/STZGPRDY\nalerted/Y\nalertness/MS\nalewife/M\nalewives\nalfalfa/MS\nalfresco\nalga/M\nalgae\nalgaecide\nalgal\nalgebra/MS\nalgebraic\nalgebraical/Y\nalgebraist/M\nalginate/SM\nalgorithm/MS\nalgorithmic\nalgorithmically\nalias/GSD\nalibi/MDSG\nalien/RDGMBS\nalienable/IU\nalienate/SDNGX\nalienation/M\nalienist/MS\nalight/DSG\nalign/LASDG\naligned/U\naligner/SM\nalignment/SAM\nalike/U\nalikeness/M\naliment/SDMG\nalimentary\nalimony/MS\nalinement's\naliquot/S\nalive/P\naliveness/MS\naliyah/M\naliyahs\nalkali/M\nalkalies\nalkaline\nalkalinity/MS\nalkalize/SDG\nalkaloid/MS\nalkyd/S\nalkyl/M\nall-time\nall/S\nallay/GDS\nallegation/SM\nallege/SDG\nalleged/Y\nallegiance/SM\nallegiant\nallegoric\nallegorical/YP\nallegoricalness/M\nallegorist/MS\nallegory/SM\nallegretto/MS\nallegri\nallegro/MS\nallele/SM\nalleluia/S\nallemande/M\nallergen/MS\nallergenic\nallergic\nallergically\nallergist/MS\nallergy/MS\nalleviate/SDVGNX\nalleviation/M\nalleviator/MS\nalley/MS\nalleyway/MS\nalliance/MS\nallier\nallies/M\nalligator/DMGS\nalliterate/XVNGSD\nalliteration/M\nalliterative/Y\nallocable/U\nallocatable\nallocate/ACSDNGX\nallocated/U\nallocation/AMC\nallocative\nallocator/AMS\nallophone/MS\nallophonic\nallot/SDL\nallotment/MS\nallotments/A\nallotrope/M\nallotropic\nallots/A\nallotted/A\nallotter/M\nallotting/A\nallover/S\nallow/SBGD\nallowable/P\nallowableness/M\nallowably\nallowance/GSDM\nallowed/Y\nallowing/E\nallows/E\nalloy/SGMD\nalloyed/U\nallspice/MS\nallude/GSD\nallure/GLSD\nallurement/SM\nalluring/Y\nallusion/MS\nallusive/PY\nallusiveness/MS\nalluvial/S\nalluvions\nalluvium/MS\nally/ASDG\nalma\nalmagest\nalmanac/MS\nalmightiness/M\nalmighty/P\nalmond/SM\nalmoner/MS\nalmost\nalms/A\nalmshouse/SM\nalmsman/M\nalnico\naloe/MS\naloft\naloha/SM\nalone/P\naloneness/M\nalong\nalongshore\nalongside\naloof/YP\naloofness/MS\naloud\nalp/MS\nalpaca/SM\nalpha/MS\nalphabet/SGDM\nalphabetic/S\nalphabetical/Y\nalphabetization/SM\nalphabetize/SRDGZ\nalphabetizer/M\nalphanumeric/S\nalphanumerical/Y\nalpine/S\nalready\nalright\nalso\nalt/RZS\naltar/MS\naltarpiece/SM\nalter/RDZBG\nalterable/UI\nalteration/MS\naltercate/NX\naltercation/M\naltered/U\nalternate/SDVGNYX\nalternation/M\nalternative/YMSP\nalternativeness/M\nalternator/MS\nalthough\naltimeter/SM\naltitude/SM\nalto/SM\naltogether/S\naltruism/SM\naltruist/SM\naltruistic\naltruistically\nalum/SM\nalumina/SM\naluminum/MS\nalumna/M\nalumnae\nalumni\nalumnus/MS\nalundum\nalveolar/Y\nalveoli\nalveolus/M\nalway/S\nam/AS\namain\namalgam/MS\namalgamate/VNGXSD\namalgamation/M\namanuenses\namanuensis/M\namaranth/M\namaranths\namaretto/S\namaryllis/MS\namass/GRSD\namasser/M\namateur/SM\namateurish/YP\namateurishness/MS\namateurism/MS\namatory\namaze/LDSRGZ\namazed/Y\namazement/MS\namazing/Y\namazon/MS\namazonian\nambassador/MS\nambassadorial\nambassadorship/MS\nambassadress/SM\namber/MS\nambergris/SM\nambiance/MS\nambidexterity/MS\nambidextrous/Y\nambience's\nambient/S\nambiguity/MS\nambiguous/YP\nambiguously/U\nambiguousness/M\nambit/M\nambition/GMDS\nambitious/PY\nambitiousness/MS\nambivalence/SM\nambivalent/Y\namble/GZDSR\nambler/M\nambrose\nambrosia/SM\nambrosial/Y\nambulance/MS\nambulant/S\nambulate/DSNGX\nambulation/M\nambulatory/S\nambuscade/MGSRD\nambuscader/M\nambush/MZRSDG\nambusher/M\nameba's\nameliorate/XVGNSD\namelioration/M\namen/DRGTSB\namenability/SM\namenably\namend/SBRDGL\namended/U\namender/M\namendment/SM\namends/M\namenity/MS\namenorrhea/M\namerce/SDLG\namercement/MS\namericanized\namericium/MS\namethyst/MS\namethystine\namiability/MS\namiable/RPT\namiableness/M\namiably\namicability/SM\namicable/P\namicableness/M\namicably\namid/S\namide/SM\namidships\namidst\namigo/MS\namines\namino/M\naminobenzoic\namir's\namiss\namity/SM\nammeter/MS\nammo/MS\nammonia/MS\nammoniac\nammonium/M\nammunition/MS\namnesia/SM\namnesiac/MS\namnesic/S\namnesty/GMSD\namniocenteses\namniocentesis/M\namnion/SM\namniotic\namoeba/SM\namoebic\namoeboid\namok/MS\namong\namongst\namontillado/MS\namoral/Y\namorality/MS\namorous/PY\namorousness/SM\namorphous/PY\namorphousness/MS\namortization/SUM\namortize/SDG\namortized/U\namount/SMRDZG\namour/MS\namp/SGMDY\namperage/SM\nampere/MS\nampersand/MS\namphetamine/MS\namphibian/SM\namphibious/PY\namphibiousness/M\namphibology/M\namphitheater/SM\namphora/M\namphorae\nample/PTR\nampleness/M\namplification/M\namplifier/M\namplify/DRSXGNZ\namplitude/MS\nampoule's\nampule/SM\namputate/DSNGX\namputation/M\namputee/SM\nams\namt\namuck's\namulet/SM\namuse/LDSRGVZ\namused/Y\namusement/SM\namuser/M\namusing/YP\namusingness/M\namyl/M\namylase/MS\nan/CS\nanabolic\nanabolism/MS\nanachronism/SM\nanachronistic\nanachronistically\nanaconda/MS\nanaerobe/SM\nanaerobic\nanaerobically\nanaglyph/M\nanagram/MS\nanagrammatic\nanagrammatically\nanagrammed\nanagramming\nanal/Y\nanalgesia/MS\nanalgesic/S\nanalog/SM\nanalogical/Y\nanalogize/SDG\nanalogous/YP\nanalogousness/MS\nanalogue/SM\nanalogy/MS\nanalysand/MS\nanalyses\nanalysis/AM\nanalyst/SM\nanalytic/S\nanalytical/Y\nanalyticity/S\nanalytics/M\nanalyzable/U\nanalyze/DRSZGA\nanalyzed/U\nanalyzer/M\nanamorphic\nanapaest's\nanapest/SM\nanapestic/S\nanaphora/M\nanaphoric\nanaphorically\nanaplasmosis/M\nanarchic\nanarchical/Y\nanarchism/MS\nanarchist/MS\nanarchistic\nanarchy/MS\nanastigmatic\nanastomoses\nanastomosis/M\nanastomotic\nanathema/MS\nanathematize/GSD\nanatomic\nanatomical/YS\nanatomist/MS\nanatomize/GSD\nanatomy/MS\nancestor/SMDG\nancestral/Y\nancestress/SM\nancestry/SM\nanchor/SGDM\nanchorage/SM\nanchored/U\nanchorite/MS\nanchoritism/M\nanchorman/M\nanchormen\nanchorpeople\nanchorperson/S\nanchorwoman\nanchorwomen\nanchovy/MS\nancient/SRYTP\nancientness/MS\nancillary/S\nand/DZGS\nandante/S\nandiron/MS\nandrogen/SM\nandrogenic\nandrogynous\nandrogyny/SM\nandroid/MS\nanecdotal/Y\nanecdote/SM\nanechoic\nanemia/SM\nanemic/S\nanemically\nanemometer/MS\nanemometry/M\nanemone/SM\nanent\naneroid\nanesthesia/MS\nanesthesiologist/MS\nanesthesiology/SM\nanesthetic/SM\nanesthetically\nanesthetist/MS\nanesthetization/SM\nanesthetize/ZSRDG\nanesthetizer/M\naneurysm/MS\nanew\nangel/MDSG\nangelfish/SM\nangelic\nangelica/MS\nangelical/Y\nanger/GDMS\nangina/MS\nangiography\nangioplasty/S\nangiosperm/MS\nangle/GMZDSRJ\nangler/M\nangleworm/MS\nanglicize/SDG\nangling/M\nangora/MS\nangrily\nangriness/M\nangry/RTP\nangst/MS\nangstrom/MS\nanguish/DSMG\nangular/Y\nangularity/MS\nanhydride/M\nanhydrite/M\nanhydrous/Y\naniline/SM\nanimadversion/SM\nanimadvert/DSG\nanimal/MYPS\nanimalcule/MS\nanimate/YNGXDSP\nanimated/A\nanimatedly\nanimately/I\nanimateness/MI\nanimates/A\nanimating/A\nanimation/AMS\nanimator/SM\nanimism/SM\nanimist/S\nanimistic\nanimized\nanimosity/MS\nanimus/SM\nanion/MS\nanionic/S\nanise/MS\naniseed/MS\naniseikonic\nanisette/SM\nanisotropic\nanisotropy/MS\nankh/M\nankhs\nankle/GMDS\nanklebone/SM\nanklet/MS\nannal/MNS\nannalist/MS\nanneal/DRSZG\nannealer/M\nannelid/MS\nannex/GSD\nannexation/SM\nannexe/M\nannihilate/XSDVGN\nannihilation/M\nannihilator/MS\nanniversary/MS\nannotate/VNGXSD\nannotated/U\nannotation/M\nannotator/MS\nannounce/ZGLRSD\nannounced/U\nannouncement/SM\nannouncer/M\nannoy/ZGSRD\nannoyance/MS\nannoyer/M\nannoying/Y\nannual/YS\nannualized\nannuitant/MS\nannuity/MS\nannul/SL\nannular/YS\nannuli\nannulled\nannulling\nannulment/MS\nannulus/M\nannum\nannunciate/XNGSD\nannunciation/M\nannunciator/SM\nanode/SM\nanodic\nanodize/GDS\nanodyne/SM\nanoint/DRLGS\nanointer/M\nanointment/SM\nanomalous/YP\nanomalousness/M\nanomaly/MS\nanomic\nanomie/M\nanon/S\nanonymity/MS\nanonymous/YP\nanonymousness/M\nanopheles/M\nanorak/SM\nanorectic/S\nanorexia/SM\nanorexic/S\nanother/M\nans/M\nanswer/MZGBSDR\nanswerable/U\nanswered/U\nanswerer/M\nant/GSMD\nantacid/MS\nantagonism/MS\nantagonist/MS\nantagonistic\nantagonistically\nantagonize/GZRSD\nantagonized/U\nantagonizing/U\nantarctic\nante/MS\nanteater/MS\nantebellum\nantecedence/MS\nantecedent/SMY\nantechamber/SM\nantedate/GDS\nantediluvian/S\nanteing\nantelope/MS\nantenatal\nantenna/MS\nantennae\nanterior/SY\nanteroom/SM\nanthem/MGDS\nanther/MS\nanthill/S\nanthologist/MS\nanthologize/GDS\nanthology/SM\nanthraces\nanthracite/MS\nanthrax/M\nanthropic\nanthropocentric\nanthropogenic\nanthropoid/S\nanthropological/Y\nanthropologist/MS\nanthropology/SM\nanthropometric/S\nanthropometry/M\nanthropomorphic\nanthropomorphically\nanthropomorphism/SM\nanthropomorphizing\nanthropomorphous\nanti/S\nantiabortion\nantiabortionist/S\nantiaircraft\nantibacterial/S\nantibiotic/SM\nantibody/MS\nantic/MS\nanticancer\nanticipate/XVGNSD\nanticipated/U\nanticipation/M\nanticipative/Y\nanticipatory\nanticked\nanticking\nanticlerical/S\nanticlimactic\nanticlimactically\nanticlimax/SM\nanticline/SM\nanticlockwise\nanticoagulant/S\nanticoagulation/M\nanticommunism/SM\nanticommunist/SM\nanticompetitive\nanticyclone/MS\nanticyclonic\nantidemocratic\nantidepressant/SM\nantidisestablishmentarianism/M\nantidote/DSMG\nantifascist/SM\nantiformant\nantifreeze/SM\nantifundamentalist/M\nantigen/MS\nantigenic\nantigenicity/SM\nantigone\nantihero/M\nantiheroes\nantihistamine/MS\nantihistorical\nantiknock/MS\nantilabor\nantilogarithm/SM\nantilogs\nantimacassar/SM\nantimalarial/S\nantimatter/SM\nantimicrobial/S\nantimissile/S\nantimony/SM\nanting/M\nantinomian\nantinomy/M\nantinuclear\nantioxidant/MS\nantiparticle/SM\nantipasti\nantipasto/MS\nantipathetic\nantipathy/SM\nantipersonnel\nantiperspirant/MS\nantiphon/SM\nantiphonal/SY\nantipodal/S\nantipode/MS\nantipodean/S\nantipollution/S\nantipoverty\nantiquarian/MS\nantiquarianism/MS\nantiquary/SM\nantiquate/NGSD\nantiquation/M\nantique/MGDS\nantiquity/SM\nantiredeposition\nantiresonance/M\nantiresonator\nantisemitic\nantisemitism/M\nantisepses\nantisepsis/M\nantiseptic/S\nantiseptically\nantiserum/SM\nantislavery/S\nantisocial/Y\nantispasmodic/S\nantisubmarine\nantisymmetric\nantisymmetry\nantitank\nantitheses\nantithesis/M\nantithetic\nantithetical/Y\nantithyroid\nantitoxin/MS\nantitrust/MR\nantivenin/MS\nantiviral/S\nantivivisectionist/S\nantiwar\nantler/SDM\nantonym/SM\nantonymous\nantral\nantsy/RT\nanus/SM\nanvil/MDSG\nanxiety/MS\nanxious/PY\nanxiousness/SM\nany\nanybody/S\nanyhow\nanymore\nanyone/MS\nanyplace\nanything/S\nanytime\nanyway/S\nanywhere/S\nanywise\naorta/MS\naortic\napace\napache/MS\napart/LP\napartheid/SM\napartment/MS\napartness/M\napathetic\napathetically\napathy/SM\napatite/MS\nape/MDRSG\naped/A\napelike\naper/A\naperiodic\naperiodically\naperiodicity/M\naperitif/S\naperture/MDS\napex/MS\naphasia/SM\naphasic/S\naphelia\naphelion/SM\naphid/MS\naphonic\naphorism/MS\naphoristic\naphoristically\naphrodisiac/SM\napiarist/SM\napiary/SM\napical/YS\napices's\napiece\napish/YP\napishness/M\naplenty\naplomb/SM\napocalypse/MS\napocalyptic\napocrypha/M\napocryphal/YP\napocryphalness/M\napogee/MS\napolar\napolitical/Y\napologetic/S\napologetically/U\napologetics/M\napologia/SM\napologist/MS\napologize/GZSRD\napologizer/M\napologizes/A\napologizing/U\napology/MS\napoplectic\napoplexy/SM\napostasy/SM\napostate/SM\napostatize/DSG\napostle/SM\napostleship/SM\napostolic\napostrophe/SM\napostrophized\napothecary/MS\napothegm/MS\napotheoses\napotheosis/M\napotheosized\napotheosizes\napotheosizing\nappall/SDG\nappalling/Y\nappaloosa/S\nappanage/M\napparatus/SM\napparel/SGMD\napparency\napparent/U\napparently/I\napparentness/M\napparition/SM\nappeal/SGMDRZ\nappealer/M\nappealing/UY\nappear/AEGDS\nappearance/AMES\nappearer/S\nappease/DSRGZL\nappeased/U\nappeasement/MS\nappeaser/M\nappellant/MS\nappellate/VNX\nappellation/M\nappellative/MY\nappend/SGZDR\nappendage/MS\nappendectomy/SM\nappendices\nappendicitis/SM\nappendix/SM\nappertain/DSG\nappetite/MVS\nappetizer/SM\nappetizing/YU\napplaud/ZGSDR\napplauder/M\napplause/MS\napple/MS\napplecart/M\napplejack/MS\napplesauce/SM\napplet/S\nappliance/SM\napplicabilities\napplicability/IM\napplicable/I\napplicably\napplicant/MS\napplicate/V\napplication/MA\napplicative/Y\napplicator/MS\napplier/SM\nappliqu/MSG\nappliqud\napply/AGSDXN\nappoint/ELSADG\nappointee/SM\nappointer/MS\nappointive\nappointment/ASEM\napportion/GADLS\napportionment/SAM\nappose/SDG\napposite/XYNVP\nappositeness/MS\napposition/M\nappositive/SY\nappraisal/SAM\nappraise/ZGDRS\nappraised/A\nappraisees\nappraiser/M\nappraises/A\nappraising/Y\nappreciable/I\nappreciably/I\nappreciate/XDSNGV\nappreciated/U\nappreciation/M\nappreciative/PIY\nappreciativeness/MI\nappreciator/MS\nappreciatory\napprehend/DRSG\napprehender/M\napprehensible\napprehension/SM\napprehensive/YP\napprehensiveness/SM\napprentice/DSGM\napprenticeship/SM\napprise/DSG\napprizer/SM\napprizingly\napprizings\napproach/BRSDZG\napproachability/UM\napproachable/UI\napproacher/M\napprobate/NX\napprobation/EMS\nappropriable\nappropriate/XDSGNVYTP\nappropriated/U\nappropriately/I\nappropriateness/SMI\nappropriation/M\nappropriator/SM\napproval/ESM\napprove/DSREG\napproved/U\napprover's/E\napprover/SM\napproving/YE\napprox\napproximate/XGNVYDS\napproximation/M\napproximative/Y\nappurtenance/MS\nappurtenant/S\napricot/MS\napron/SDMG\napropos\napse/MS\napsis/M\napt/UPYI\napter\naptest\naptitude/SM\naptness's/U\naptness/SMI\naqua/SM\naquaculture/MS\naqualung/SM\naquamarine/SM\naquanaut/SM\naquaplane/GSDM\naquarium/MS\naquatic/S\naquatically\naquavit/SM\naqueduct/MS\naqueous/Y\naquiculture's\naquifer/SM\naquiline\narabesque/SM\narability/MS\narable/S\narachnid/MS\narachnoid/M\narachnophobia\narbiter/MS\narbitrage/GMZRSD\narbitrager/M\narbitrageur/S\narbitrament/MS\narbitrarily\narbitrariness/MS\narbitrary/P\narbitrate/SDXVNG\narbitration/M\narbitrator/SM\narbor/DMS\narboreal/Y\narbores\narboretum/MS\narborvitae/MS\narbutus/SM\narc/DSGM\narcade/SDMG\narcana/M\narcane/P\narch/PGVZTMYDSR\narchaeological/Y\narchaeologist/SM\narchaic/P\narchaically\narchaism/SM\narchaist/MS\narchaize/GDRSZ\narchaizer/M\narchangel/SM\narchbishop/SM\narchbishopric/SM\narchdeacon/MS\narchdiocesan\narchdiocese/SM\narchduchess/MS\narchduke/MS\narchenemy/SM\narcheologist's\narcheology/MS\narcher/M\narchery/MS\narchetypal\narchetype/SM\narchfiend/SM\narchfool\narchiepiscopal\narching/M\narchipelago/SM\narchitect/MS\narchitectonic/S\narchitectonics/M\narchitectural/Y\narchitecture/SM\narchitrave/MS\narchival\narchive/DRSGMZ\narchived/U\narchivist/MS\narchness/MS\narchway/SM\narclike\narcsine\narctangent\narctic/S\nardency/M\nardent/Y\nardor/SM\narduous/YP\narduousness/SM\nare/BS\narea/SM\nareal\nareawide\naren't\narena/SM\narenaceous\nargent/MS\narginine/MS\nargon/MS\nargonaut/S\nargosy/SM\nargot/SM\narguable/IU\narguably/IU\nargue/DSRGZ\narguer/M\nargument/SM\nargumentation/SM\nargumentative/YP\nargumentativeness/MS\nargyle/S\naria/SM\narid/TYRP\naridity/SM\naridness/M\naright\narise/GJSR\narisen\naristocracy/SM\naristocrat/MS\naristocratic\naristocratically\narithmetic/MS\narithmetical/Y\narithmetician/SM\narithmetize/SD\nark/MS\narm's\narm/ASEDG\narmada/SM\narmadillo/MS\narmament's/E\narmament/EAS\narmature/MGSD\narmband/SM\narmchair/MS\narmed/U\narmer/MES\narmful/SM\narmhole/MS\narming/M\narmistice/MS\narmless\narmlet/SM\narmload/M\narmor/ZRDMGS\narmored/U\narmorer/M\narmorial/S\narmory/DSM\narmpit/MS\narmrest/MS\narmy/SM\naroma/SM\naromatherapist/S\naromatherapy/S\naromatic/SP\naromatically\naromaticity/M\naromaticness/M\narose\naround\narousal/MS\narouse/GSD\naroused/U\narpeggio/SM\narr/TV\narrack/M\narraign/SDGL\narraignment/MS\narrange/ZDSRLG\narrangeable/A\narranged/EA\narrangement/AMSE\narranger/M\narranges/EA\narranging/EA\narrant/Y\narras/SM\narray/ESGMD\narrayer\narrear/SM\narrest/ADSG\narrestee/MS\narrester/MS\narresting/Y\narrestor/MS\narrhythmia/SM\narrhythmic\narrhythmical\narrival/MS\narrive/SRDG\narriver/M\narrogance/MS\narrogant/Y\narrogate/XNGDS\narrogation/M\narrow/SDMG\narrowhead/SM\narrowroot/MS\narroyo/MS\narsenal/MS\narsenate/M\narsenic/MS\narsenide/M\narsine/MS\narson/SM\narsonist/MS\nart/SM\nartefact's\narterial/SY\narteriolar\narteriole/SM\narterioscleroses\narteriosclerosis/M\nartery/SM\nartesian\nartful/YP\nartfulness/SM\narthritic/S\narthritides\narthritis/M\narthrogram/MS\narthropod/SM\narthroscope/S\narthroscopic\nartichoke/SM\narticle/GMDS\narticulable/I\narticular\narticulate/VGNYXPSD\narticulated/EU\narticulately/I\narticulateness/IMS\narticulates/I\narticulation/M\narticulator/SM\narticulatory\nartifact/MS\nartifice/ZRSM\nartificer/M\nartificial/PY\nartificiality/MS\nartificialness/M\nartillerist\nartillery/SM\nartilleryman/M\nartillerymen\nartiness/MS\nartisan/SM\nartist/MS\nartiste/SM\nartistic/I\nartistically/I\nartistry/SM\nartless/YP\nartlessness/MS\nartsy/RT\nartwork/MS\narty/TPR\narum/MS\nas\nasap\nasbestos/MS\nascend/ADGS\nascendancy/MS\nascendant/SY\nascender/SM\nascension/SM\nascent/SM\nascertain/DSBLG\nascertainment/MS\nascetic/SM\nascetically\nasceticism/MS\nascot/MS\nascribe/GSDB\nascription/MS\nascriptive\naseptic/S\naseptically\nasexual/Y\nasexuality/MS\nash/MNDRSG\nashame/D\nashamed/UY\nashcan/SM\nashlar/GSDM\nashman/M\nashore\nashram/SM\nashtray/MS\nashy/RT\naside/S\nasinine/Y\nasininity/MS\nask/DRZGS\naskance\nasked/U\nasker/M\naskew/P\naslant\nasleep\nasocial/S\nasp/MNRXS\nasparagus/MS\naspartame/S\naspect/SM\naspen/M\nasper/M\nasperity/SM\naspersion/SM\nasphalt/MDRSG\nasphodel/MS\nasphyxia/MS\nasphyxiate/GNXSD\nasphyxiation/M\naspic/MS\naspidistra/MS\naspirant/MS\naspirate/NGDSX\naspiration/M\naspirational\naspirator/SM\naspire/GSRD\naspirer/M\naspirin/SM\nasplenium\nass/MNS\nassail/BGDS\nassailable/U\nassailant/SM\nassassin/MS\nassassinate/DSGNX\nassassination/M\nassault/SGVMDR\nassaulter/M\nassaultive/YP\nassay/SZGRD\nassayer/M\nassemblage/MS\nassemble/ADSREG\nassembled/U\nassembler/EMS\nassemblies/A\nassembly/EAM\nassemblyman/M\nassemblymen\nassemblywoman\nassemblywomen\nassent/SGMRD\nassert/ADGS\nasserter/MS\nassertion/AMS\nassertional\nassertive/PY\nassertiveness/SM\nassess/BLSDG\nassessed/A\nassesses/A\nassessment/SAM\nassessor/MS\nasset/SM\nasseverate/XSDNG\nasseveration/M\nasshole/MS!\nassiduity/SM\nassiduous/PY\nassiduousness/SM\nassign/ALBSGD\nassignation/MS\nassigned/U\nassignee/MS\nassigner/MS\nassignment/MAS\nassignor/MS\nassigns/CU\nassimilate/VNGXSD\nassimilation/M\nassimilationist/M\nassist/RDGS\nassistance/SM\nassistant/SM\nassistantship/SM\nassisted/U\nassister/M\nassize/MGSD\nassn\nassoc\nassociable\nassociate/SDEXNG\nassociated/U\nassociateship\nassociation/ME\nassociational\nassociative/Y\nassociativity/S\nassociator/MS\nassonance/SM\nassonant/S\nassort/LRDSG\nassorter/M\nassortment/SM\nasst\nassuage/SDG\nassuaged/U\nassumability\nassume/SRDBJG\nassumer/M\nassuming/UA\nassumption/SM\nassumptive\nassurance/AMS\nassure/AGSD\nassured/PYS\nassuredness/M\nassurer/SM\nassuring/YA\nastatine/MS\naster/ESM\nasteria\nasterisk/SGMD\nasterisked/U\nastern\nasteroid/SM\nasteroidal\nasthma/MS\nasthmatic/S\nastigmatic/S\nastigmatism/SM\nastir\nastonish/GSDL\nastonishing/Y\nastonishment/SM\nastound/SDG\nastounding/Y\nastraddle\nastrakhan/SM\nastral/SY\nastray\nastride\nastringency/SM\nastringent/YS\nastrolabe/MS\nastrologer/MS\nastrological/Y\nastrologist/M\nastrology/SM\nastronaut/SM\nastronautic/S\nastronautical\nastronautics/M\nastronomer/MS\nastronomic\nastronomical/Y\nastronomy/SM\nastrophysical\nastrophysicist/SM\nastrophysics/M\nastute/RTYP\nastuteness/MS\nasunder\nasylum/MS\nasymmetric\nasymmetrical/Y\nasymmetry/MS\nasymptomatic\nasymptomatically\nasymptote/MS\nasymptotic/Y\nasymptotically\nasynchronism/M\nasynchronous/Y\nasynchrony\nat\natavism/MS\natavist/MS\natavistic\nataxia/MS\nataxic/S\nate/S\natelier/SM\natemporal\natheism/SM\natheist/SM\natheistic\natheroscleroses\natherosclerosis/M\nathirst\nathlete/MS\nathletic/S\nathletically\nathleticism/M\nathletics/M\nathwart\natilt\natlantes\natlas/SM\natmosphere/DSM\natmospheric/S\natmospherically\natoll/MS\natom/SM\natomic/S\natomically\natomicity/M\natomics/M\natomistic\natomization/SM\natomize/GZDRS\natomizer/M\natonal/Y\natonality/MS\natone/LDSG\natonement/SM\natop\natria\natrial\natrium/M\natrocious/YP\natrociousness/SM\natrocity/SM\natrophic\natrophy/DSGM\natropine/SM\nattach/BLGZMDRS\nattached/UA\nattacher/M\nattachment/ASM\nattach/S\nattack/GBZSDR\nattacker/M\nattain/AGSD\nattainabilities\nattainability/UM\nattainable/U\nattainableness/M\nattainably/U\nattainder/MS\nattained/U\nattainer/MS\nattainment/MS\nattar/MS\nattempt/ADSG\nattempter/MS\nattend/SGZDR\nattendance/MS\nattendant/SM\nattended/U\nattendee/SM\nattender/M\nattention/IMS\nattentional\nattentionality\nattentive/YIP\nattentiveness/IMS\nattenuate/SDXGN\nattenuated/U\nattenuation/M\nattenuator/MS\nattest/GSDR\nattestation/SM\nattested/U\nattester/M\nattic/MS\nattire/SDG\nattitude/MS\nattitudinal/Y\nattitudinize/SDG\nattn\nattorney/SM\nattract/BSDGV\nattractant/SM\nattraction/MS\nattractive/UYP\nattractiveness/UM\nattractivenesses\nattractor/MS\nattributable/U\nattribute/BVNGRSDX\nattributed/U\nattributer/M\nattribution/M\nattributional\nattributive/SY\nattrition/MS\nattune/SDG\natty\natwitter\natypical/Y\naubergine/MS\nauburn/SM\nauction/MDSG\nauctioneer/SDMG\naudacious/PY\naudaciousness/SM\naudacity/MS\naudibility/MSI\naudible/I\naudibles\naudibly/I\naudience/MS\naudio/SM\naudiogram/SM\naudiological\naudiologist/MS\naudiology/SM\naudiometer/MS\naudiometric\naudiometry/M\naudiophile/SM\naudiotape/S\naudiovisual/S\naudit/SMDVG\naudited/U\naudition/MDSG\nauditor/MS\nauditorium/MS\nauditory/S\nauger/SM\naught/S\naugment/DRZGS\naugmentation/SM\naugmentative/S\naugmenter/M\naugur/GDMS\naugury/SM\naugust/STPYR\naugustness/SM\nauk/MS\naunt/MYS\nauntie/MS\naunty's\naura/SM\naural/Y\naureole/GMSD\naureomycin\nauric\nauricle/SM\nauricular\naurora/SM\nauroral\nauscultate/XDSNG\nauscultation/M\nauspice/SM\nauspicious/IPY\nauspiciousness/IM\nauspiciousnesses\naustere/TYRP\naustereness/M\nausterity/SM\naustral\naustrales\naustralites\nauthentic/UI\nauthentically\nauthenticate/GNDSX\nauthenticated/U\nauthentication/M\nauthenticator/MS\nauthenticity/MS\nauthor/DMGS\nauthoress/S\nauthorial\nauthoritarian/S\nauthoritarianism/MS\nauthoritative/PY\nauthoritativeness/SM\nauthority/SM\nauthorization/MAS\nauthorize/AGDS\nauthorized/U\nauthorizer/SM\nauthorizes/U\nauthorship/MS\nautism/MS\nautistic/S\nauto/SDMG\nautobahn/MS\nautobiographer/MS\nautobiographic\nautobiographical/Y\nautobiography/MS\nautoclave/SDGM\nautocollimator/M\nautocorrelate/GNSDX\nautocorrelation/M\nautocracy/SM\nautocrat/SM\nautocratic\nautocratically\nautodial/R\nautodidact/MS\nautofluorescence\nautograph/MDG\nautographs\nautoignition/M\nautoimmune\nautoimmunity/S\nautoloader\nautomaker/S\nautomata's\nautomate/NGDSX\nautomatic/S\nautomatically\nautomation/M\nautomatism/SM\nautomatize/DSG\nautomaton/SM\nautomobile/GDSM\nautomorphism/SM\nautomotive\nautonavigator/SM\nautonomic/S\nautonomous/Y\nautonomy/MS\nautopilot/SM\nautopsy/MDSG\nautoregressive\nautorepeat/GS\nautostart\nautosuggestibility/M\nautotransformer/M\nautoworker/S\nautumn/MS\nautumnal/Y\naux\nauxiliary/S\nauxin/MS\nav/ZR\navail/BSZGRD\navailability/USM\navailable/U\navailableness/M\navailably\navailing/U\navalanche/MGSD\navant\navarice/SM\navaricious/PY\navariciousness/M\navast/S\navatar/MS\navaunt/S\navdp\nave/S\navenge/ZGSRD\navenged/U\navenger/M\navenue/MS\naverage/DSPGYM\naverred\naverrer\naverring\navers/V\naverse/YNXP\naverseness/M\naversion/M\navert/GSD\naves/C\navg\navian/S\naviary/SM\naviate/NX\naviation/M\naviator/SM\naviatrices\naviatrix/SM\navid/TPYR\navidity/MS\navionic/S\navionics/M\navitaminoses\navitaminosis/M\navocado/MS\navocation/SM\navocational\navoid/ZRDBGS\navoidable/U\navoidably/U\navoidance/SM\navoider/M\navoirdupois/MS\navouch/GDS\navow/GEDS\navowal/EMS\navowed/Y\navower/M\navuncular\naw/GD\nawait/SDG\nawake/GS\nawaken/SADG\nawakened/U\nawakener/M\nawakening/S\naward/RDSZG\nawarder/M\naware/TRP\nawareness/MSU\nawash\naway/PS\nawe/SM\naweigh\nawesome/PY\nawesomeness/SM\nawestruck\nawful/YP\nawfuller\nawfullest\nawfulness/SM\nawhile/S\nawkward/PRYT\nawkwardness/MS\nawl/MS\nawn/MDJGS\nawning/DM\nawoke\nawoken\nawry/RT\nax/DRSZGM\naxehead/S\naxeman\naxial/Y\naxillary\naxiological/Y\naxiology/M\naxiom/SM\naxiomatic/S\naxiomatically\naxiomatization/MS\naxiomatize/GDS\naxion/SM\naxis/SM\naxle/MS\naxletree/MS\naxolotl/SM\naxon/SM\nayah/M\nayahs\nayatollah\nayatollahs\naye/MZRS\nazalea/SM\nazimuth/M\nazimuthal/Y\nazimuths\nazure/MS\nb/KGD\nbaa/SDG\nbabbitt/GDS\nbabble/RSDGZ\nbabbler/M\nbabe/SM\nbabel/S\nbaboon/MS\nbabushka/MS\nbaby/TDSRMG\nbabyhood/MS\nbabyish\nbabysat\nbabysit/S\nbabysitter/S\nbabysitting\nbaccalaureate/MS\nbaccarat/SM\nbacchanal/SM\nbacchanalia\nbacchanalian/S\nbachelor/SM\nbachelorhood/SM\nbacillary\nbacilli\nbacillus/MS\nback/GZDRMSJ\nbackache/SM\nbackarrow\nbackbench/ZR\nbackbencher/M\nbackbit/ZGJR\nbackbite/S\nbackbiter/M\nbackbitten\nbackboard/SM\nbackbone/SM\nbackbreaking\nbackchaining\nbackcloth/M\nbackdate/GDS\nbackdrop/MS\nbackdropped\nbackdropping\nbacked/U\nbacker/M\nbackfield/SM\nbackfill/SDG\nbackfire/GDS\nbackgammon/MS\nbackground/SDRMZG\nbackhand/RDMSZG\nbackhanded/Y\nbackhander/M\nbackhoe/S\nbacking/M\nbacklash/GRSDM\nbackless\nbacklog/MS\nbacklogged\nbacklogging\nbackorder\nbackpack/ZGSMRD\nbackpacker/M\nbackpedal/DGS\nbackplane/MS\nbackplate/SM\nbackrest/MS\nbackscatter/SMDG\nbackseat/S\nbackside/SM\nbackslapper/MS\nbackslapping/M\nbackslash/DSG\nbackslid/RZG\nbackslide/S\nbackslider/M\nbackspace/GSD\nbackspin/SM\nbackstabber/M\nbackstabbing\nbackstage\nbackstair/S\nbackstitch/GDSM\nbackstop/MS\nbackstopped\nbackstopping\nbackstreet/M\nbackstretch/SM\nbackstroke/GMDS\nbacktalk/S\nbacktrack/SDRGZ\nbackup/SM\nbackward/YSP\nbackwardness/MS\nbackwash/SDMG\nbackwater/SM\nbackwood/S\nbackwoodsman/M\nbackwoodsmen\nbackyard/MS\nbacon/SRM\nbaconer/M\nbacteria/MS\nbacterial/Y\nbactericidal\nbactericide/SM\nbacteriologic\nbacteriological\nbacteriologist/MS\nbacteriology/SM\nbacterium/M\nbad/PSNY\nbadder\nbaddest\nbaddie/MS\nbade\nbadge/DSRGMZ\nbadger/DMG\nbadinage/DSMG\nbadland/S\nbadman/M\nbadmen\nbadminton/MS\nbadmouth/DG\nbadmouths\nbadness/SM\nbaffle/RSDGZL\nbafflement/MS\nbaffler/M\nbaffling/Y\nbag/SM\nbagatelle/MS\nbagel/SM\nbagful/MS\nbaggage/SM\nbaggageman\nbaggagemen\nbagged/M\nbagger/SM\nbaggily\nbagginess/MS\nbagging/M\nbaggy/PRST\nbagpipe/RSMZ\nbagpiper/M\nbaguette/SM\nbah\nbahs\nbail/GSMYDRB\nbailiff/SM\nbailiwick/MS\nbailout/MS\nbailsman/M\nbailsmen\nbairn/SM\nbait/GSMDR\nbaiter/M\nbaize/GMDS\nbake/ZGJDRS\nbaked/U\nbakehouse/M\nbaker/M\nbakery/SM\nbakeshop/S\nbaking/M\nbaklava/M\nbaksheesh/SM\nbalaclava/MS\nbalalaika/MS\nbalance's\nbalance/USDG\nbalanced/A\nbalancedness\nbalancer/MS\nbalboa/SM\nbalcony/MSD\nbald/PYDRGST\nbalderdash/MS\nbaldfaced\nbaldness/MS\nbaldric/SM\nbaldy\nbale/MZGDRS\nbaleen/MS\nbaleful/YP\nbalefuller\nbalefullest\nbalefulness/MS\nbaler/M\nbalk/GDRS\nbalkanization\nbalkanize/DG\nbalker/M\nbalkiness/M\nbalky/PRT\nball/GZMSDR\nballad/SM\nballade/MS\nballadeer/MS\nballadry/MS\nballast/SGMD\nballcock/S\nballer/M\nballerina/MS\nballet/MS\nballetic\nballfields\nballgame/S\nballistic/S\nballistics/M\nballoon/RDMZGS\nballoonist/S\nballot/MRDGS\nballoter/M\nballpark/SM\nballplayer/SM\nballpoint/SM\nballroom/SM\nballsy/TR\nballyhoo/SGMD\nbalm/MS\nbalminess/SM\nbalmy/PRT\nbaloney/SM\nbalsa/MS\nbalsam/GMDS\nbalsamic\nbaluster/MS\nbalustrade/SM\nbamboo/SM\nbamboozle/GSD\nban/SGMD\nbanal/TYR\nbanality/MS\nbanana/SM\nband's\nband/EDGS\nbandage/RSDMG\nbandager/M\nbandanna/SM\nbandbox/MS\nbandeau/M\nbandeaux\nbander/M\nbanding/M\nbandit/MS\nbanditry/MS\nbandmaster/MS\nbandoleer/SM\nbandpass\nbandsman/M\nbandsmen\nbandstand/SM\nbandstop\nbandwagon/MS\nbandwidth/M\nbandwidths\nbandy/TGRSD\nbane/MS\nbaneful/Y\nbanefuller\nbanefullest\nbang/GDRZMS\nbanger/M\nbangkok\nbangle/MS\nbani\nbanish/RSDGL\nbanisher/M\nbanishment/MS\nbanister/MS\nbanjo/MS\nbanjoist/SM\nbank/GZJDRMBS\nbankbook/SM\nbankcard/S\nbanker/M\nbanking/M\nbanknote/S\nbankroll/DMSG\nbankrupt/DMGS\nbankruptcy/MS\nbanned/U\nbanner/SDMG\nbanning/U\nbannister's\nbannock/SM\nbanns\nbanquet/SZGJMRD\nbanqueter/M\nbanquette/MS\nbans/U\nbanshee/MS\nbantam/MS\nbantamweight/MS\nbanter/RDSG\nbanterer/M\nbantering/Y\nbanyan/MS\nbanzai/S\nbaobab/SM\nbaptism/SM\nbaptismal/Y\nbaptist/MS\nbaptistery/MS\nbaptistry's\nbaptize/SRDZG\nbaptized/U\nbaptizer/M\nbaptizes/U\nbar/TGMDRS\nbarb/DRMSGZ\nbarbarian/MS\nbarbarianism/MS\nbarbaric\nbarbarically\nbarbarism/MS\nbarbarity/SM\nbarbarize/SDG\nbarbarous/PY\nbarbarousness/M\nbarbecue/DRSMG\nbarbed/P\nbarbel/MS\nbarbell/SM\nbarbeque's\nbarber/DMG\nbarbered/U\nbarberry/MS\nbarbershop/MS\nbarbital/M\nbarbiturate/MS\nbarbwire/SM\nbarcarole/SM\nbard/MDSG\nbardic\nbare/YSP\nbareback/D\nbarefaced/YP\nbarefacedness/M\nbarefoot/D\nbarehanded\nbareheaded\nbarelegged\nbareness/MS\nbarf/YDSG\nbarfly/SM\nbargain/ZGSDRM\nbargainer/M\nbarge/DSGM\nbargeman/M\nbargemen\nbargepole/M\nbarhop/S\nbarhopped\nbarhopping\nbaritone/MS\nbarium/MS\nbark/GZDRMS\nbarked/C\nbarkeep/SRZ\nbarkeeper/M\nbarker/M\nbarks/C\nbarley/MS\nbarleycorn/MS\nbarmaid/SM\nbarman/M\nbarmen\nbarn/GDSM\nbarnacle/MDS\nbarnful\nbarnsful\nbarnstorm/DRGZS\nbarnstormer/M\nbarnyard/MS\nbarometer/MS\nbarometric\nbarometrically\nbaron/SM\nbaronage/MS\nbaroness/MS\nbaronet/MS\nbaronetcy/SM\nbaronial\nbarony/SM\nbaroque/SPMY\nbarque's\nbarrack/SDRG\nbarracker/M\nbarracuda/MS\nbarrage/MGSD\nbarre/GMDSJ\nbarred/ECU\nbarrel/SGMD\nbarren/SPRT\nbarrenness/SM\nbarrette/SM\nbarricade/SDMG\nbarrier/MS\nbarring/R\nbarrio/SM\nbarrister/MS\nbarroom/SM\nbarrow/MS\nbars/ECU\nbarstool/SM\nbartend/ZR\nbartender/M\nbarter/SRDZG\nbarterer/M\nbarycenter\nbarycentre's\nbarycentric\nbaryon/SM\nbas/DRSTG\nbasal/Y\nbasalt/SM\nbasaltic\nbase's\nbase/CGRSDL\nbaseball/MS\nbaseband\nbaseboard/MS\nbaseless\nbaseline/SM\nbasely\nbaseman/M\nbasemen\nbasement/CSM\nbaseness/MS\nbaseplate/M\nbasetting\nbash/JGDSR\nbashful/PY\nbashfulness/MS\nbasic/S\nbasically\nbasil/MS\nbasilar\nbasilica/SM\nbasilisk/SM\nbasin/DMS\nbasinful/S\nbasis/M\nbask/GSD\nbasket/SM\nbasketball/MS\nbasketry/MS\nbasketwork/SM\nbasophilic\nbass/SM\nbasset/GMDS\nbassinet/SM\nbassist/MS\nbasso/MS\nbassoon/MS\nbassoonist/MS\nbasswood/SM\nbast/SGZMDR\nbastard/MYS\nbastardization/MS\nbastardize/SDG\nbastardized/U\nbastardy/MS\nbaste/NXS\nbaster/M\nbasting/M\nbastion/DM\nbat/SMDRG\nbatch/MRSDG\nbate/KGSADC\nbated/U\nbater/AC\nbath/JMDSRGZ\nbathe\nbather/M\nbathetic\nbathhouse/SM\nbathmat/S\nbathos/SM\nbathrobe/MS\nbathroom/SDM\nbaths\nbathtub/MS\nbathwater\nbathyscaphe's\nbathysphere/MS\nbatik/DMSG\nbatiste/SM\nbatman/M\nbatmen\nbaton/SM\nbatsman/M\nbatsmen\nbattalion/MS\nbatted\nbatten/SDMG\nbatter/SRDZG\nbattery/MS\nbatting/MS\nbattle/GMZRSDL\nbattledore/MS\nbattledress\nbattlefield/SM\nbattlefront/SM\nbattleground/SM\nbattlement/SMD\nbattler/M\nbattleship/MS\nbatty/RT\nbatwings\nbauble/SM\nbaud/M\nbaulk/GSDM\nbauxite/SM\nbawd/SM\nbawdily\nbawdiness/MS\nbawdy/PRST\nbawl/SGDR\nbawler/M\nbay/GSMDY\nbayberry/MS\nbayonet/SGMD\nbayou/MS\nbazaar/MS\nbazillion/S\nbazooka/MS\nbbl\nbdrm\nbe/KS\nbeach/MSDG\nbeachcomber/SM\nbeachhead/SM\nbeachwear/M\nbeacon/DMSG\nbead/SJGMD\nbeading/M\nbeadle/SM\nbeadsman/M\nbeadworker\nbeady/TR\nbeagle/SDGM\nbeak/ZSDRM\nbeaker/M\nbeam/MDRSGZ\nbean/DRMGZS\nbeanbag/SM\nbeanie/SM\nbeanpole/MS\nbeanstalk/SM\nbear/ZBRSJG\nbearable/U\nbearably/U\nbeard/DSGM\nbearded/P\nbeardless\nbearer/M\nbearing/M\nbearish/PY\nbearishness/SM\nbearlike\nbearskin/MS\nbeast/SJMY\nbeasties\nbeastings/M\nbeastliness/MS\nbeastly/PTR\nbeat/NRGSBZJ\nbeatable/U\nbeatably/U\nbeaten/U\nbeater/M\nbeatific\nbeatifically\nbeatification/M\nbeatify/GNXDS\nbeating/M\nbeatitude/MS\nbeatnik/SM\nbeau/MS\nbeaut/SM\nbeauteous/YP\nbeauteousness/M\nbeautician/MS\nbeautification/M\nbeautifier/M\nbeautiful/PTYR\nbeautifully/U\nbeautifulness/M\nbeautify/SRDNGXZ\nbeauty/SM\nbeaux's\nbeaver/DMSG\nbebop/MS\nbecalm/GDS\nbecame\nbecause\nbeck/GSDM\nbeckon/SDG\nbecloud/SGD\nbecome/GJS\nbecoming/UY\nbed/MS\nbedaub/GDS\nbedazzle/GLDS\nbedazzlement/SM\nbedbug/SM\nbedchamber/M\nbedclothes\nbedded\nbedder/MS\nbedding/MS\nbedeck/DGS\nbedevil/DGLS\nbedevilment/SM\nbedfast\nbedfellow/MS\nbedim/S\nbedimmed\nbedimming\nbedizen/DGS\nbedlam/MS\nbedlinen\nbedmaker/SM\nbedmate/MS\nbedpan/SM\nbedpost/SM\nbedraggle/GSD\nbedridden\nbedrock/SM\nbedroll/SM\nbedroom/DMS\nbedsheets\nbedside/MS\nbedsit\nbedsitter/M\nbedsore/MS\nbedspread/SM\nbedspring/SM\nbedstead/SM\nbedstraw/M\nbedtime/SM\nbee/MZGJRS\nbeebread/MS\nbeech/MRSN\nbeechnut/MS\nbeechwood\nbeef/GZSDRM\nbeefburger/SM\nbeefcake/MS\nbeefiness/MS\nbeefsteak/MS\nbeefy/TRP\nbeehive/MS\nbeekeeper/MS\nbeekeeping/SM\nbeeline/MGSD\nbeen/S\nbeep/GZSMDR\nbeeper/M\nbeer/M\nbeermat/S\nbeery/TR\nbeeswax/DSMG\nbeet/SM\nbeetle/GMRSD\nbeetroot/M\nbeeves/M\nbefall/SGN\nbefell\nbefit/SM\nbefitted\nbefitting/Y\nbefog/S\nbefogged\nbefogging\nbefore\nbeforehand\nbefoul/GSD\nbefriend/DGS\nbefuddle/GLDS\nbefuddlement/SM\nbeg/S\nbegan\nbeget/S\nbegetting\nbeggar/DYMSG\nbeggarliness/M\nbeggarly/P\nbeggary/MS\nbegged\nbegging\nbegin/S\nbeginner/MS\nbeginning/MS\nbegone/S\nbegonia/SM\nbegot\nbegotten\nbegrime/SDG\nbegrudge/GDRS\nbegrudging/Y\nbeguile/RSDLZG\nbeguilement/SM\nbeguiler/M\nbeguiling/Y\nbeguine/SM\nbegum/MS\nbegun\nbehalf/M\nbehalves\nbehave/GRSD\nbehavior/SMD\nbehavioral/Y\nbehaviorism/MS\nbehaviorist/S\nbehavioristic/S\nbehead/GSD\nbeheld\nbehemoth/M\nbehemoths\nbehest/SM\nbehind/S\nbehindhand\nbehold/ZGRNS\nbeholder/M\nbehoofs\nbehoove/SDJMG\nbehooving/YM\nbeige/MS\nbeing/M\nbejewel/SDG\nbelabor/MDSG\nbelate/D\nbelated/PY\nbelatedness/M\nbelay/GSD\nbelch/GSD\nbeleaguer/GDS\nbelfry/SM\nbelie\nbelief/ESUM\nbelier/M\nbelievability's\nbelievability/U\nbelievable/U\nbelievably/U\nbelieve/EZGDRS\nbelieved/U\nbeliever/MUSE\nbelieving/U\nbelittle/RSDGL\nbelittlement/MS\nbelittler/M\nbell/GSMD\nbelladonna/MS\nbellboy/MS\nbelle/MS\nbelled/A\nbelletrist/SM\nbelletristic\nbellflower/M\nbellhop/MS\nbellicose/YP\nbellicoseness/M\nbellicosity/MS\nbelligerence/SM\nbelligerency/MS\nbelligerent/SMY\nbelling/A\nbellman/M\nbellmen\nbellow/DGS\nbellows/M\nbells/A\nbellwether/MS\nbelly/SDGM\nbellyache/SRDGM\nbellyacher/M\nbellybutton/MS\nbellyful/MS\nbellyfull\nbelong/DGJS\nbelonging/MP\nbelove/D\nbeloved/S\nbelow/S\nbelt/GSMD\nbelted/U\nbelting/M\nbeltway/SM\nbeluga/SM\nbelvedere/M\nbely/DSRG\nbeman\nbemire/SDG\nbemoan/GDS\nbemuse/GSDL\nbemused/Y\nbemusement/SM\nbench/MRSDG\nbencher/M\nbenchmark/GDMS\nbend/BUSG\nbended\nbender/MS\nbeneath\nbenediction/MS\nbenedictory\nbenefaction/MS\nbenefactor/MS\nbenefactress/S\nbenefice/MGSD\nbeneficence/SM\nbeneficent/Y\nbeneficial/PY\nbeneficialness/M\nbeneficiary/MS\nbenefit/SRDMZG\nbenefiter/M\nbenevolence/SM\nbenevolent/YP\nbenevolentness/M\nbenighted/YP\nbenightedness/M\nbenign/Y\nbenignant\nbenignity/MS\nbent/U\nbents\nbentwood/SM\nbenumb/SGD\nbenzene/MS\nbenzine/SM\nbequeath/GSD\nbequeaths\nbequest/MS\nberate/GSD\nbereave/GLSD\nbereavement/MS\nbereft\nberet/SM\nberg/NRSM\nberibbon/D\nberiberi/SM\nberkelium/SM\nberm/SM\nberry/SDMG\nberrylike\nberserk/SR\nberserker/M\nberth/MDGJ\nberths\nberyl/SM\nberyllium/MS\nbes\nbeseech/RSJZG\nbeseecher/M\nbeseeching/Y\nbeseem/GDS\nbeset/S\nbesetting\nbeside/S\nbesiege/SRDZG\nbesieger/M\nbesmear/GSD\nbesmirch/GSD\nbesom/GMDS\nbesot/S\nbesotted\nbesotting\nbesought\nbespangle/GSD\nbespatter/SGD\nbespeak/SG\nbespectacled\nbespoke\nbespoken\nbest/DRSG\nbestial/Y\nbestiality/MS\nbestiary/MS\nbestir/S\nbestirred\nbestirring\nbestow/SGD\nbestowal/SM\nbestrew/DGS\nbestrewn\nbestridden\nbestride/SG\nbestrode\nbestseller/MS\nbestselling\nbestubble/D\nbet/MS\nbeta/SM\nbetake/SG\nbetaken\nbetatron/M\nbetcha\nbetel/MS\nbeth/M\nbethel/M\nbethink/GS\nbethought\nbetide/GSD\nbetimes\nbetoken/GSD\nbetook\nbetray/SRDZG\nbetrayal/SM\nbetrayer/M\nbetroth/GD\nbetrothal/SM\nbetrothed/U\nbetroths\nbetter/SDLG\nbetterment/MS\nbetting\nbettor/SM\nbetween/SP\nbetweenness/M\nbetwixt\nbevel/SJGMRD\nbeverage/MS\nbevy/SM\nbewail/GDS\nbeware/GSD\nbewhisker/D\nbewigged\nbewilder/LDSG\nbewildered/PY\nbewildering/Y\nbewilderment/SM\nbewitch/LGDS\nbewitching/Y\nbewitchment/SM\nbey/MS\nbeyond/S\nbezel/MS\nbf\nbi/M\nbiannual/Y\nbias/DSMPG\nbiased/U\nbiathlon/MS\nbiaxial/Y\nbib/MS\nbibbed\nbibbing\nbible/MS\nbiblical/Y\nbiblicists\nbibliographer/MS\nbibliographic/S\nbibliographical/Y\nbibliography/MS\nbibliophile/MS\nbibulous\nbicameral\nbicameralism/MS\nbicarb/MS\nbicarbonate/MS\nbicentenary/S\nbicentennial/S\nbicep/S\nbiceps/M\nbichromate/DM\nbicker/SRDZG\nbickerer/M\nbickering/M\nbiconcave\nbiconnected\nbiconvex\nbicuspid/S\nbicycle/RSDMZG\nbicycler/M\nbicyclist/SM\nbid/GMRS\nbiddable\nbidden/U\nbidder/MS\nbidding/MS\nbiddy/SM\nbide/S\nbider/M\nbidet/SM\nbidiagonal\nbidirectional/Y\nbids/A\nbiennial/SY\nbiennium/SM\nbier/M\nbifocal/S\nbifurcate/SDXGNY\nbifurcation/M\nbig/PYS\nbigamist/SM\nbigamous\nbigamy/SM\nbigged\nbigger\nbiggest\nbiggie/SM\nbigging\nbiggish\nbighead/MS\nbighearted/P\nbigheartedness/S\nbighorn/MS\nbight/SMDG\nbigmouth/M\nbigmouths\nbigness/SM\nbigot/MDSG\nbigoted/Y\nbigotry/MS\nbigwig/MS\nbiharmonic\nbijection/MS\nbijective/Y\nbijou/M\nbijoux\nbike/MZGDRS\nbiker/M\nbikini/SMD\nbilabial/S\nbilateral/PY\nbilateralness/M\nbilayer/S\nbilberry/MS\nbile/SM\nbilge/GMDS\nbiliary\nbilinear\nbilingual/SY\nbilingualism/SM\nbilious/P\nbiliousness/SM\nbilk/GZSDR\nbilker/M\nbill/JGZSBMDR\nbillboard/MDGS\nbiller/M\nbillet/MDGS\nbillfold/MS\nbilliard/SM\nbilling/M\nbillingsgate/SM\nbillion/SHM\nbillionaire/MS\nbillionths\nbillow/DMGS\nbillowy/RT\nbillposters\nbilly/SM\nbimbo/MS\nbimetallic/S\nbimetallism/MS\nbimodal\nbimolecular/Y\nbimonthly/S\nbin/SM\nbinary/S\nbinaural/Y\nbind/JDRGZS\nbinder/M\nbindery/MS\nbinding/MPY\nbindingness/M\nbindle/M\nbinds/AU\nbindweed/MS\nbing/GNDM\nbinge/MS\nbingo/MS\nbinnacle/MS\nbinned\nbinning\nbinocular/SY\nbinodal\nbinomial/SYM\nbinuclear\nbiochemical/SY\nbiochemist/MS\nbiochemistry/MS\nbiodegradability/S\nbiodegradable\nbiodiversity/S\nbioengineering/M\nbioethics\nbiofeedback/SM\nbiog/S\nbiograph/RZ\nbiographer/M\nbiographic\nbiographical/Y\nbiography/MS\nbiol\nbiologic/S\nbiological/SY\nbiologist/SM\nbiology/MS\nbiomass/SM\nbiomedical\nbiomedicine/M\nbiometric/S\nbiometrics/M\nbiometry/M\nbiomolecule/S\nbiomorph\nbionic/S\nbionically\nbionics/M\nbiophysic/S\nbiophysical/Y\nbiophysicist/SM\nbiophysics/M\nbiopic/S\nbiopsy/SDGM\nbiorhythm/S\nbioscience/S\nbiosphere/MS\nbiostatistic/S\nbiosynthesized\nbiotechnological\nbiotechnologist\nbiotechnology/SM\nbiotic\nbiotin/SM\nbipartisan\nbipartisanship/MS\nbipartite/YN\nbipartition/M\nbiped/MS\nbipedal\nbiplane/MS\nbipolar\nbipolarity/MS\nbiracial\nbirch/MRSDNG\nbird/SMDRGZ\nbirdbath/M\nbirdbaths\nbirdbrain/SDM\nbirdcage/SM\nbirder/M\nbirdhouse/MS\nbirdie/MSD\nbirdieing\nbirdlike\nbirdlime/MGDS\nbirdseed/MS\nbirdsong\nbirdtables\nbirdwatch/GZR\nbirefringence/M\nbirefringent\nbiretta/SM\nbirth's/A\nbirth/MDG\nbirthday/SM\nbirthmark/MS\nbirthplace/SM\nbirthrate/MS\nbirthright/MS\nbirths/A\nbirthstone/SM\nbis\nbiscuit/MS\nbisect/DSG\nbisection/MS\nbisector/MS\nbiserial\nbisexual/YMS\nbisexuality/MS\nbishop/DGSM\nbishopric/SM\nbismuth/M\nbismuths\nbison/M\nbisque/SM\nbistable\nbistate\nbistro/SM\nbisyllabic\nbit's/C\nbit/MRJSZG\nbitblt/S\nbitch/MSDG\nbitchily\nbitchiness/MS\nbitchy/PTR\nbite/S\nbiter/M\nbiting/Y\nbitmap/SM\nbits/C\nbitser/M\nbitted\nbitten\nbitter/PSRDYTG\nbittern/SM\nbitterness/SM\nbitternut/M\nbitterroot/M\nbittersweet/YMSP\nbitting\nbitty/PRT\nbitumen/MS\nbituminous\nbitwise\nbivalent/S\nbivalve/MSD\nbivariate\nbivouac/MS\nbivouacked\nbivouacking\nbiweekly/S\nbiyearly\nbiz/M\nbizarre/YSP\nbizarreness/M\nbizzes\nbk\nbl/D\nblab/S\nblabbed\nblabber/GMDS\nblabbermouth/M\nblabbermouths\nblabbing\nblack/SJTXPYRDNG\nblackamoor/SM\nblackball/SDMG\nblackberry/GMS\nblackbird/SGDRM\nblackbirder/M\nblackboard/SM\nblackbody/S\nblackcurrant/M\nblacken/GDR\nblackener/M\nblackguard/MDSG\nblackhead/SM\nblacking/M\nblackish\nblackjack/SGMD\nblackleg/M\nblacklist/DRMSG\nblackmail/DRMGZS\nblackmailer/M\nblackness/MS\nblackout/SM\nblacksmith/MG\nblacksmiths\nblacksnake/MS\nblackspot\nblackthorn/MS\nblacktop/MS\nblacktopped\nblacktopping\nbladder/MS\nbladdernut/M\nbladderwort/M\nblade/DSGM\nblah/MDG\nblahs\nblame/DSRBGMZ\nblameless/YP\nblamelessness/SM\nblamer/M\nblameworthiness/SM\nblameworthy/P\nblanc/M\nblanch/DRSG\nblancher/M\nblancmange/SM\nbland/PYRT\nblandish/SDGL\nblandishment/MS\nblandness/MS\nblank/SPGTYRD\nblanket/SDRMZG\nblanketing/M\nblankness/MS\nblare/DSG\nblarney/DMGS\nblaspheme/RSDZG\nblasphemer/M\nblasphemous/PY\nblasphemousness/M\nblasphemy/SM\nblast/SMRDGZ\nblaster/M\nblasting/M\nblastoff/SM\nblas\nblatancy/SM\nblatant/YP\nblather/DRGS\nblatting\nblaze/DSRGMZ\nblazer/M\nblazing/Y\nblazon/SGDR\nblazoner/M\nbldg\nbleach/DRSZG\nbleached/U\nbleacher/M\nbleak/TPYRS\nbleakness/MS\nblear/GDS\nblearily\nbleariness/SM\nbleary/PRT\nbleat/RDGS\nbleater/M\nbleed/ZRJSG\nbleeder/M\nbleep/GMRDZS\nblemish/DSMG\nblemished/U\nblench/DSG\nblend/GZRDS\nblender/M\nbless/JGSD\nblessed/PRYT\nblessedness/MS\nblessing/M\nblew\nblight/GSMDR\nblighter/M\nblimey/S\nblimp/MS\nblind/JGTZPYRDS\nblinded/U\nblinder/M\nblindfold/SDG\nblinding/MY\nblindness/MS\nblindside/SDG\nblink/RDGSZ\nblinker/MDG\nblinking/U\nblinks/M\nblintz/SM\nblintze/M\nblip/MS\nblipped\nblipping\nbliss/SDMG\nblissful/PY\nblissfulness/MS\nblister/SMDG\nblistering/Y\nblistery\nblithe/TYPR\nblitheness/SM\nblither/G\nblithesome\nblitz/GSDM\nblitzkrieg/SM\nblizzard/MS\nbloat/SRDGZ\nbloater/M\nblob/MS\nblobbed\nblobbing\nbloc/MS\nblock's\nblock/USDG\nblockade/ZMGRSD\nblockader/M\nblockage/MS\nblockbuster/SM\nblockbusting/MS\nblocker/MS\nblockhead/MS\nblockhouse/SM\nblocky/R\nblog\nblog's\nblogged\nblogger\nblogging\nblogging's\nblogs\nbloke/SM\nblond/SPMRT\nblonde's\nblondish\nblondness/MS\nblood/SMDG\nbloodbath\nbloodbaths\nbloodcurdling\nbloodhound/SM\nbloodied/U\nbloodiness/MS\nbloodless/PY\nbloodlessness/SM\nbloodletting/MS\nbloodline/SM\nbloodmobile/MS\nbloodroot/M\nbloodshed/SM\nbloodshot\nbloodsport/S\nbloodstain/MDS\nbloodstock/SM\nbloodstone/M\nbloodstream/SM\nbloodsucker/SM\nbloodsucking/S\nbloodthirstily\nbloodthirstiness/MS\nbloodthirsty/RTP\nbloodworm/M\nbloody/TPGDRS\nbloodymindedness\nbloom/SMRDGZ\nbloomer/M\nbloop/GSZRD\nblooper/M\nblossom/DMGS\nblossomy\nblot/MS\nblotch/GMDS\nblotchy/RT\nblotted\nblotter/MS\nblotting\nblotto\nblouse/GMSD\nblow/GZRS\nblower/M\nblowfish/M\nblowfly/MS\nblowgun/SM\nblowing/M\nblown/U\nblowout/MS\nblowpipe/SM\nblowtorch/SM\nblowup/MS\nblowy/RST\nblowzy/RT\nblubber/GSDR\nblubbery\nbludgeon/GSMD\nblue/JMYTGDRSP\nblueback\nbluebell/MS\nblueberry/SM\nbluebill/M\nbluebird/MS\nbluebonnet/SM\nbluebook/M\nbluebottle/MS\nbluebush\nbluefish/SM\nbluegill/SM\nbluegrass/MS\nblueing's\nblueish\nbluejacket/MS\nbluejeans\nblueness/MS\nbluenose/MS\nbluepoint/SM\nblueprint/GDMS\nbluer/M\nbluest/M\nbluestocking/SM\nbluesy/TR\nbluet/MS\nbluff/SPGTZYRD\nbluffer/M\nbluffness/MS\nbluing/M\nbluish/P\nbluishness/M\nblunder/GSMDRJZ\nblunderbuss/MS\nblunderer/M\nblundering/Y\nblunt/PSGTYRD\nbluntness/MS\nblur/MS\nblurb/GSDM\nblurred/Y\nblurriness/S\nblurring/Y\nblurry/RPT\nblurt/GSRD\nblush/RSDGZ\nblusher/M\nblushing/UY\nbluster/SDRZG\nblusterer/M\nblustering/Y\nblusterous\nblustery\nblvd\nboa/SM\nboar/MS\nboard's\nboard/IS\nboarded\nboarder/SM\nboardgames\nboarding/SM\nboardinghouse/SM\nboardroom/MS\nboardwalk/SM\nboast/SJRDGZ\nboaster/M\nboastful/YP\nboastfulness/MS\nboat/MDRGZJS\nboatclubs\nboater/M\nboathouse/SM\nboating/M\nboatload/SM\nboatman/M\nboatmen\nboatswain/SM\nboatyard/SM\nbob/SM\nbobbed\nbobbin/MS\nbobbing/M\nbobble/SDGM\nbobby/SM\nbobbysoxer's\nbobcat/MS\nbobolink/SM\nbobs/M\nbobsled/MS\nbobsledded\nbobsledder/MS\nbobsledding/M\nbobsleigh/M\nbobsleighs\nbobtail/SGDM\nbobwhite/SM\nboccie/SM\nbock/GDS\nbockwurst\nbod/SGMD\nbode/S\nbodega/MS\nbodhisattva\nbodice/SM\nbodied/M\nbodiless\nbodily\nboding/M\nbodkin/SM\nbody/DSMG\nbodybuilder/SM\nbodybuilding/S\nbodyguard/MS\nbodying/M\nbodysuit/S\nbodyweight\nbodywork/SM\nbog/MS\nbogey/SGMD\nbogeyman/M\nbogeymen\nbogged\nbogging\nboggle/SDG\nboggling/Y\nboggy/RT\nbogie's\nbogus\nbogy's\nbogyman\nbogymen\nbohemian/S\nbohemianism/S\nboil/JSGZDR\nboiled/AU\nboiler/M\nboilermaker/MS\nboilerplate/SM\nboils/A\nboisterous/YP\nboisterousness/MS\nbola/SM\nbold/YRPST\nboldface/SDMG\nboldness/MS\nbole/MS\nbolero/MS\nbolivar/MS\nbolivares\nboll/MDSG\nbollard/SM\nbollix/GSD\nbolo/MS\nbologna/MS\nbolometer/MS\nboloney's\nbolster/SRDG\nbolsterer/M\nbolt/MDRGS\nbolted/U\nbolter/M\nbolts/U\nbolus/SM\nbomb/SGZDRJ\nbombard/LDSG\nbombardier/MS\nbombardment/SM\nbombast/RMS\nbombastic\nbombastically\nbomber/M\nbombproof\nbombshell/SM\nbona\nbonanza/MS\nbonbon/SM\nbond/JMDRSGZ\nbondage/SM\nbonder/M\nbondholder/SM\nbondman/M\nbondmen\nbonds/A\nbondsman/M\nbondsmen\nbondwoman/M\nbondwomen\nbone/MZDRSG\nboned/U\nbonehead/SDM\nboneless\nboner/M\nbonfire/MS\nbong/GDMS\nbongo/MS\nbonhomie/MS\nboniness/MS\nbonito/MS\nbonjour\nbonkers\nbonnet/SGMD\nbonneted/U\nbonnie\nbonny/RT\nbonsai/SM\nbonus/SM\nbony/RTP\nbonzes\nboo/GSDH\nboob/DMSG\nbooby/SM\nboodle/GMSD\nboogeyman's\nboogie/SD\nboogieing\nboohoo/GDS\nbook/GZDRMJSB\nbookbind/JRGZ\nbookbinder/M\nbookbindery/SM\nbookbinding/M\nbookcase/MS\nbooked/U\nbookend/SGD\nbookie/SM\nbooking/M\nbookish/PY\nbookishness/M\nbookkeep/GZJR\nbookkeeper/M\nbookkeeping/M\nbooklet/MS\nbookmaker/MS\nbookmaking/MS\nbookmark/MDGS\nbookmobile/MS\nbookplate/SM\nbookseller/SM\nbookshelf/M\nbookshelves\nbookshop/MS\nbookstall/MS\nbookstore/SM\nbookwork/M\nbookworm/MS\nboolean/S\nboom/DRGJS\nboomer/M\nboomerang/MDSG\nboomtown/S\nboon/MS\nboondocks\nboondoggle/DRSGZ\nboondoggler/M\nboonies\nboor/MS\nboorish/PY\nboorishness/SM\nboost/SGZMRD\nbooster/M\nboosterism\nboot's\nboot/AGDS\nbootblack/MS\nbootee/MS\nbooth/M\nbooths\nbootie's\nbootlaces\nbootleg/S\nbootlegged/M\nbootlegger/SM\nbootlegging/M\nbootless\nbootprints\nbootstrap/SM\nbootstrapped\nbootstrapping\nbooty/SM\nbooze/DSRGMZ\nboozer/M\nboozy/TR\nbop/S\nbopped\nbopping\nborate/MSD\nborax/MS\nbordello/MS\nborder/JRDMGS\nborderer/M\nborderland/SM\nborderline/MS\nbore/ZGJDRS\nboredom/MS\nboreholes\nborer/M\nboric\nboring/YMP\nborn/AIU\nborne/U\nboron/SM\nborosilicate/M\nborough/M\nboroughs\nborrow/JZRDGBS\nborrower/M\nborrowing/M\nborscht/SM\nborstal/MS\nborzoi/MS\nbosh/MS\nbosom's\nbosom/SGUD\nbosomy/RT\nboson/SM\nboss/DSRMG\nbossily\nbossiness/MS\nbossism/MS\nbossy/PTSR\nbosun's\nbot/S\nbotanic/S\nbotanical/SY\nbotanist/SM\nbotany/SM\nbotch/SRDGZ\nbotcher/M\nbotfly/M\nboth/ZR\nbother/DG\nbothersome\nbothy/M\nbottle/GMZSRD\nbottleneck/GSDM\nbottler/M\nbottom/SMRDG\nbottomless/YP\nbottomlessness/M\nbottommost\nbotulin/M\nbotulinus/M\nbotulism/SM\nboudoir/MS\nbouffant/S\nbougainvillea/SM\nbough/MD\nboughs\nbought/N\nbouillabaisse/MS\nbouillon/MS\nboulder/GMDS\nboulevard/MS\nbounce/SRDGZ\nbouncer/M\nbouncily\nbouncing/Y\nbouncy/TRP\nbound/AUDI\nboundary/MS\nbounded/UP\nboundedness/MU\nbounden\nbounder/AM\nbounders\nbounding\nboundless/YP\nboundlessness/SM\nbounds/IA\nbounteous/PY\nbounteousness/MS\nbountiful/PY\nbountifulness/SM\nbounty/SDM\nbouquet/SM\nbourbon/SM\nbourgeois/M\nbourgeoisie/SM\nbout/MS\nboutique/MS\nboutonnire/MS\nbovine/YS\nbow/SZGNDR\nbowdlerization/MS\nbowdlerize/GRSD\nbowed/U\nbowel/GMDS\nbower/DMG\nbowie\nbowing/M\nbowl/GZSMDR\nbowlder's\nbowleg/SM\nbowlegged\nbowler/M\nbowlful/S\nbowline/MS\nbowling/M\nbowman/M\nbowmen\nbows/R\nbowser/M\nbowsprit/SM\nbowstring/GSMD\nbowwow/DMGS\nbox/DRSJZGM\nboxcar/SM\nboxer/M\nboxful/M\nboxing/M\nboxlike\nboxtops\nboxwood/SM\nboxy/TPR\nboy/MRS\nboycott/RDGS\nboycotter/M\nboyfriend/MS\nboyhood/SM\nboyish/PY\nboyishness/MS\nboyscout\nboysenberry/SM\nbozo/SM\nbpi\nbps\nbra/MS\nbrace/DSRJGM\nbraced/U\nbracelet/MS\nbracer/M\nbrachia\nbrachium/M\nbracken/SM\nbracket/SGMD\nbracketed/U\nbracketing/M\nbrackish/P\nbrackishness/SM\nbract/SM\nbrad/SM\nbradawl/M\nbradded\nbradding\nbrae/SM\nbrag/S\nbraggadocio/SM\nbraggart/SM\nbragged\nbragger/MS\nbraggest\nbragging\nbraid/RDSJG\nbraider/M\nbraiding/M\nbraille/DSG\nbrain/GSDM\nbraincell/S\nbrainchild/M\nbrainchildren\nbraininess/MS\nbrainless/YP\nbrainlessness/M\nbrainpower/M\nbrainstorm/DRMGJS\nbrainstorming/M\nbrainteaser/S\nbrainteasing\nbrainwash/JGRSD\nbrainwasher/M\nbrainwashing/M\nbrainwave/S\nbrainy/RPT\nbraise/SDG\nbrake/DSGM\nbrakeman/M\nbrakemen/M\nbramble/DSGM\nbrambling/M\nbrambly/RT\nbran/SM\nbranch/MDSJG\nbranched/U\nbranching/M\nbranchlike\nbrand/SMRDGZ\nbranded/U\nbrander/GDM\nbrandish/GSD\nbrandy/GDSM\nbrandywine\nbranned\nbranning\nbrash/PYSRT\nbrashness/MS\nbrass/GSDM\nbrasserie/SM\nbrassiere/MS\nbrassily\nbrassiness/SM\nbrassy/RSPT\nbrat/SM\nbratty/RT\nbratwurst/MS\nbravado/M\nbravadoes\nbrave/DSRGYTP\nbraveness/MS\nbravery/MS\nbravest/M\nbravo/SDG\nbravura/SM\nbrawl/MRDSGZ\nbrawler/M\nbrawn/MS\nbrawniness/SM\nbrawny/TRP\nbray/SDRG\nbrayer/M\nbraze/GZDSR\nbrazen/PYDSG\nbrazenness/MS\nbrazer/M\nbrazier/SM\nbreach/MDRSGZ\nbreacher/M\nbread/SMDHG\nbreadbasket/SM\nbreadboard/SMDG\nbreadbox/S\nbreadcrumb/S\nbreadfruit/MS\nbreadline/MS\nbreadth/M\nbreadths\nbreadwinner/MS\nbreak/SZRBG\nbreakable/U\nbreakables\nbreakage/MS\nbreakaway/MS\nbreakdown/MS\nbreaker/M\nbreakfast/RDMGZS\nbreakfaster/M\nbreakfront/S\nbreaking/M\nbreakneck\nbreakout/MS\nbreakpoint/SMDG\nbreakthrough/SM\nbreakthroughs\nbreakup/SM\nbreakwater/SM\nbream/SDG\nbreast/MDSG\nbreastbone/MS\nbreastfed\nbreastfeed/G\nbreasting/M\nbreastplate/SM\nbreaststroke/SM\nbreastwork/MS\nbreath/ZBJMDRSG\nbreathable/U\nbreathalyser/S\nbreathe\nbreather/M\nbreathing/M\nbreathless/PY\nbreathlessness/SM\nbreaths\nbreathtaking/Y\nbreathy/TR\nbred/DG\nbredes\nbreech/MDSG\nbreeching/M\nbreed/SZJRG\nbreeder's\nbreeder/I\nbreeding/IM\nbreeds/I\nbreeze/GMSD\nbreezeway/SM\nbreezily\nbreeziness/SM\nbreezy/RPT\nbremsstrahlung/M\nbrethren\nbreve/SM\nbrevet/MS\nbrevetted\nbrevetting\nbreviary/SM\nbrevity/MS\nbrew/DRGZS\nbrewer/M\nbrewery/MS\nbrewing/M\nbrewpub/S\nbriar's\nbribe/GZDSR\nbriber/M\nbribery/MS\nbrick/GRDSM\nbrickbat/SM\nbricklayer/MS\nbricklaying/SM\nbrickmason/S\nbrickwork/SM\nbrickyard/M\nbridal/S\nbride/MS\nbridegroom/MS\nbridesmaid/MS\nbridge/SDGM\nbridgeable/U\nbridged/U\nbridgehead/MS\nbridgework/MS\nbridging/M\nbridle/SDGM\nbridled/U\nbridleway/S\nbrief/YRDJPGTS\nbriefcase/SM\nbriefed/C\nbriefing/M\nbriefness/MS\nbriefs/C\nbrier/MS\nbrig/SM\nbrigade/GDSM\nbrigadier/MS\nbrigand/MS\nbrigandage/MS\nbrigantine/MS\nbright/GXTPSYNR\nbrighten/RDZG\nbrightener/M\nbrightness/SM\nbrilliance/MS\nbrilliancy/MS\nbrilliant/PSY\nbrilliantine/MS\nbrilliantness/M\nbrim/SM\nbrimful\nbrimless\nbrimmed\nbrimming\nbrimstone/MS\nbrindle/DSM\nbrine/GMDSR\nbriner/M\nbring/RGZS\nbringer/M\nbrininess/MS\nbrink/MS\nbrinkmanship/SM\nbriny/PTSR\nbrioche/SM\nbriquet's\nbriquette/MGSD\nbrisk/YRDPGTS\nbrisket/SM\nbriskness/MS\nbristle/DSGM\nbristly/TR\nbristol/S\nbritches\nbrittle/YTPDRSG\nbrittleness/MS\nbro/SH\nbroach/DRSG\nbroacher/M\nbroad/TXSYRNP\nbroadband\nbroadcast/RSGZJ\nbroadcaster/M\nbroadcasts/A\nbroadcloth/M\nbroadcloths\nbroaden/JGRDZ\nbroadleaved\nbroadloom/SM\nbroadminded/P\nbroadness/S\nbroadsheet/MS\nbroadside/SDGM\nbroadsword/MS\nbrocade/DSGM\nbroccoli/MS\nbrochette/SM\nbrochure/SM\nbrogan/MS\nbrogue/MS\nbroil/RDSGZ\nbroiler/M\nbroke/RGZ\nbroken/YP\nbrokenhearted/Y\nbrokenness/MS\nbroker/DMG\nbrokerage/MS\nbromide/MS\nbromidic\nbromine/MS\nbronc/S\nbronchi/M\nbronchial\nbronchiolar\nbronchiole/MS\nbronchiolitis\nbronchitic/S\nbronchitis/MS\nbroncho's\nbronchus/M\nbronco/SM\nbroncobuster/SM\nbrontosaur/SM\nbrontosaurus/SM\nbronze/SRDGM\nbronzed/M\nbronzing/M\nbrooch/MS\nbrood/SMRDGZ\nbrooder/M\nbroodiness/M\nbrooding/Y\nbroodmare/SM\nbroody/PTR\nbrook/SGDM\nbrooklet/MS\nbrookside\nbroom/SMDG\nbroomstick/MS\nbros/S\nbroth/ZMR\nbrothel/MS\nbrother/DYMG\nbrotherhood/SM\nbrotherliness/MS\nbrotherly/P\nbroths\nbrougham/MS\nbrought\nbrouhaha/MS\nbrow/MS\nbrowbeat/NSG\nbrown/YRDMSJGTP\nbrownie/MTRS\nbrowning/M\nbrownish\nbrownness/MS\nbrownout/MS\nbrownstone/MS\nbrows/SRDGZ\nbrowse\nbrowser/M\nbrr\nbrucellosis/M\nbruin/MS\nbruise/JGSRDZ\nbruised/U\nbruiser/M\nbruit/DSG\nbrunch/MDSG\nbrunet/S\nbrunette/SM\nbrunt/GSMD\nbrush/MSRDG\nbrusher/M\nbrushfire/MS\nbrushlike\nbrushoff/S\nbrushwood/SM\nbrushwork/MS\nbrushy/R\nbrusque/PYTR\nbrusqueness/MS\nbrutal/Y\nbrutality/SM\nbrutalization/SM\nbrutalize/SDG\nbrutalized/U\nbrutalizes/AU\nbrute/DSRGM\nbrutish/YP\nbrutishness/SM\nbu\nbub/MS\nbubble/RSDGM\nbubblegum/S\nbubbler/M\nbubbly/TRS\nbubo/M\nbuboes\nbubonic\nbuccaneer/GMDS\nbuck/GSDRM\nbuckaroo/SM\nbuckboard/SM\nbucker/M\nbucket/SGMD\nbucketful/MS\nbuckeye/SM\nbuckhorn/M\nbuckle/RSDGMZ\nbuckled/U\nbuckler/MDG\nbuckles/U\nbuckling's\nbuckling/U\nbuckram/GSDM\nbucksaw/SM\nbuckshot/MS\nbuckskin/SM\nbuckteeth\nbucktooth/DM\nbuckwheat/SM\nbucolic/S\nbucolically\nbud/MS\nbudded\nbudding/S\nbuddy/GSDM\nbudge/GDS\nbudgerigar/MS\nbudget/GMRDZS\nbudgetary\nbudgeter/M\nbudgie/MS\nbudging/U\nbuff's\nbuff/ASGD\nbuffalo/MDG\nbuffaloes\nbuffer/RDMSGZ\nbuffered/U\nbufferer/M\nbuffet/GMDJS\nbufflehead/M\nbuffoon/SM\nbuffoonery/MS\nbuffoonish\nbug's\nbug/CS\nbugaboo/SM\nbugbear/SM\nbugeyed\nbugged/C\nbugger/SCM!\nbuggered\nbuggering\nbuggery/M\nbugging/C\nbuggy/RSMT\nbugle/GMDSRZ\nbugler/M\nbuild/SAG\nbuilder/SM\nbuilding/SM\nbuildup/MS\nbuilt/AUI\nbulb/DMGS\nbulblet\nbulbous\nbulge/DSGM\nbulgy/RT\nbulimarexia/S\nbulimia/MS\nbulimic/S\nbulk/GDRMS\nbulkhead/SDM\nbulkiness/SM\nbulky/RPT\nbull/MDGS\nbulldog/SM\nbulldogged\nbulldogger\nbulldogging\nbulldoze/GRSDZ\nbulldozer/M\nbullet/GMDS\nbulletin/SGMD\nbulletproof/SGD\nbullfight/SJGZMR\nbullfighter/M\nbullfighting/M\nbullfinch/MS\nbullfrog/SM\nbullhead/DMS\nbullheaded/YP\nbullheadedness/SM\nbullhide\nbullhorn/SM\nbullied/M\nbullion/SM\nbullish/PY\nbullishness/SM\nbullock/MS\nbullpen/MS\nbullring/SM\nbullseye\nbullshit/MS!\nbullshitted/!\nbullshitter/S!\nbullshitting/!\nbullwhackers\nbully/TRSDGM\nbullyboy/MS\nbullying/M\nbulrush/SM\nbulwark/GMDS\nbum/SM\nbumble/JGZRSD\nbumblebee/MS\nbumbler/M\nbumbling/Y\nbummed/M\nbummer/MS\nbummest\nbumming/M\nbump/GZDRS\nbumper/DMG\nbumpiness/MS\nbumpkin/MS\nbumptious/PY\nbumptiousness/SM\nbumpy/PRT\nbun/SM\nbunch/MSDG\nbunchy/RT\nbunco's\nbuncombe's\nbundle/GMRSD\nbundled/U\nbundler/M\nbung/GDMS\nbungalow/MS\nbungee/SM\nbunghole/MS\nbungle/GZRSD\nbungler/M\nbungling/Y\nbunion/SM\nbunk's\nbunk/CSGDR\nbunker's/C\nbunker/SDMG\nbunkhouse/SM\nbunkmate/MS\nbunko's\nbunkum/SM\nbunny/SM\nbunt/GJZDRS\nbunting/M\nbuoy/SMDG\nbuoyancy/MS\nbuoyant/Y\nbur/MYS\nburble/RSDG\nburbler/M\nburbs\nburden's\nburden/UGDS\nburdensome/PY\nburdensomeness/M\nburdock/SM\nbureau/MS\nbureaucracy/MS\nbureaucrat/MS\nbureaucratic/U\nbureaucratically\nbureaucratization/MS\nbureaucratize/SDG\nburg/SZRM\nburgeon/GDS\nburger/M\nburgess/MS\nburgh/MRZ\nburgher/M\nburghs\nburglar/SM\nburglarize/GDS\nburglarproof/DGS\nburglary/MS\nburgle/SDG\nburgomaster/SM\nburgundy/S\nburial/ASM\nburied/U\nburier/M\nburl/SMDRG\nburlap/MS\nburler/M\nburlesque/SRDMYG\nburlesquer/M\nburley/M\nburliness/SM\nburly/PRT\nburn/GZSDRBJ\nburnable/S\nburned/U\nburner/M\nburning/Y\nburnish/GDRSZ\nburnisher/M\nburnoose/MS\nburnout/MS\nburnt/YP\nburp/SGMD\nburr/GSDRM\nburrito/S\nburro/SM\nburrow/GRDMZS\nburrower/M\nbursa/M\nbursae\nbursar/MS\nbursary/MS\nbursitis/MS\nburst/SRG\nburster/M\nbury/ASDG\nbus's/A\nbus/GMDSJ\nbusboy/MS\nbusby/SM\nbuses/A\nbusgirl/S\nbush/JMDSRG\nbushel/MDJSG\nbushiness/MS\nbushing/M\nbushland\nbushman/M\nbushmaster/SM\nbushmen\nbushwhack/RDGSZ\nbushwhacker/M\nbushwhacking/M\nbushy/PTR\nbusily\nbusiness/MS\nbusinesslike\nbusinessman/M\nbusinessmen\nbusinesspeople\nbusinessperson/S\nbusinesswoman/M\nbusinesswomen\nbusk/GRM\nbusker/M\nbuskin/SM\nbuss/D\nbust/MSDRGZ\nbustard/MS\nbuster/M\nbustle/GSD\nbustling/Y\nbusty/RT\nbusy/DSRPTG\nbusybody/MS\nbusyness/MS\nbusywork/SM\nbut/ACS\nbutane/MS\nbutch/RSZ\nbutcher/MDRYG\nbutcherer/M\nbutchery/MS\nbutene/M\nbutler/SDMG\nbutt/SGZMDR\nbutte/MS\nbutted/A\nbutter/RDMGZ\nbutterball/MS\nbuttercup/SM\nbuttered/U\nbutterfat/MS\nbutterfingered\nbutterfingers/M\nbutterfly/MGSD\nbuttermilk/MS\nbutternut/MS\nbutterscotch/SM\nbuttery/TRS\nbutting/M\nbuttock/SGMD\nbutton's\nbutton/SUDG\nbuttoner/M\nbuttonhole/GMRSD\nbuttonholer/M\nbuttonweed\nbuttonwood/SM\nbuttress/MSDG\nbutyl/M\nbutyrate/M\nbuxom/TPYR\nbuxomness/M\nbuy/ZGRS\nbuyback/S\nbuyer/M\nbuyout/S\nbuzz/DSRMGZ\nbuzzard/MS\nbuzzer/M\nbuzzword/SM\nbuzzy\nbx\nbxs\nby/ZR\nbye/MZS\nbyelaw's\nbygone/S\nbylaw/SM\nbyline/RSDGM\nbyliner/M\nbypass/GSDM\nbypath/M\nbypaths\nbyplay/S\nbyproduct/SM\nbyre/SM\nbyroad/MS\nbystander/SM\nbyte/SM\nbyway/SM\nbyword/SM\nbyzantine\nc/B\nca\ncab/SMR\ncabal/SM\ncabala/MS\ncaballed\ncaballero/SM\ncaballing\ncabana/MS\ncabaret/SM\ncabbage/MGSD\ncabbed\ncabbing\ncabby's\ncabdriver/SM\ncaber/M\ncabin/GDMS\ncabinet/MS\ncabinetmaker/SM\ncabinetmaking/MS\ncabinetry/SM\ncabinetwork/MS\ncable/GMDS\ncablecast/SG\ncablegram/SM\ncabochon/MS\ncaboodle/SM\ncaboose/MS\ncabriolet/MS\ncabstand/MS\ncacao/SM\ncacciatore\ncache/DSRGM\ncachepot/MS\ncachet/MDGS\ncackle/RSDGZ\ncackler/M\ncackly\ncacophonist\ncacophonous\ncacophony/SM\ncacti\ncactus/M\ncad/SM\ncadaver/SM\ncadaverous/Y\ncaddish/PY\ncaddishness/SM\ncaddy/GSDM\ncadence/CSM\ncadenced\ncadencing\ncadent/C\ncadenza/MS\ncadet/SM\ncadge/DSRGZ\ncadger/M\ncadmium/MS\ncadre/SM\ncaducei\ncaduceus/M\ncaesura/SM\ncafeteria/SM\ncaffeine/SM\ncaftan/SM\ncaf/MS\ncage/MZGDRS\ncaged/U\ncager/M\ncagey/P\ncagier\ncagiest\ncagily\ncaginess/MS\ncahoot/MS\ncaiman's\ncairn/SDM\ncaisson/SM\ncaitiff/MS\ncajole/LGZRSD\ncajolement/MS\ncajoler/M\ncajolery/SM\ncake/MGDS\ncakewalk/SMDG\ncal/C\ncalabash/SM\ncalaboose/MS\ncalamari/S\ncalamine/GSDM\ncalamitous/YP\ncalamitousness/M\ncalamity/MS\ncalcareous/PY\ncalcareousness/M\ncalciferous\ncalcification/M\ncalcify/XGNSD\ncalcimine/GMSD\ncalcine/SDG\ncalcite/SM\ncalcium/SM\ncalculability/IM\ncalculable/IP\ncalculate/AXNGDS\ncalculated/PY\ncalculating/U\ncalculatingly\ncalculation/AM\ncalculative\ncalculator/SM\ncalculi\ncalculus/M\ncaldera/SM\ncaldron's\ncalendar/MDGS\ncalender/MDGS\ncalf/M\ncalfskin/SM\ncaliber/SM\ncalibrate/XNGSD\ncalibrated/U\ncalibrater's\ncalibrating/A\ncalibration/M\ncalibrator/MS\ncalico/M\ncalicoes\ncalif's\ncalifornium/SM\ncaliper/SDMG\ncaliph/M\ncaliphate/SM\ncaliphs\ncalisthenic/S\ncalisthenics/M\ncall/AGRDBS\ncalla/MS\ncallback/S\ncalled/U\ncallee/M\ncaller/MS\ncalligraph/RZ\ncalligrapher/M\ncalligraphic\ncalligraphist/MS\ncalligraphy/MS\ncalling/SM\ncalliope/SM\ncallisthenics's\ncallosity/MS\ncallous/PGSDY\ncallousness/SM\ncallow/RTSP\ncallowness/MS\ncallus/SDMG\ncalm/PGTYDRS\ncalming/Y\ncalmness/MS\ncaloric/S\ncalorie/SM\ncalorific\ncalorimeter/MS\ncalorimetric\ncalorimetry/M\ncalumet/MS\ncalumniate/NGSDX\ncalumniation/M\ncalumniator/SM\ncalumnious\ncalumny/MS\ncalvary/M\ncalve/GDS\ncalves/M\ncalyces's\ncalypso/SM\ncalyx/MS\ncam/MS\ncamaraderie/SM\ncamber/DMSG\ncambial\ncambium/SM\ncambric/MS\ncamcorder/S\ncame/N\ncamel/SM\ncamelhair's\ncamellia/MS\ncameo/GSDM\ncamera/MS\ncamerae\ncameraman/M\ncameramen\ncamerawoman\ncamerawomen\ncamion/M\ncamisole/MS\ncammed\ncamomile's\ncamouflage/DRSGZM\ncamouflager/M\ncamp's\ncamp/SCGD\ncampaign/ZMRDSG\ncampaigner/M\ncampanile/SM\ncampanological\ncampanologist/SM\ncampanology/MS\ncamper/SM\ncampesinos\ncampest\ncampfire/SM\ncampground/MS\ncamphor/MS\ncamping/S\ncampsite/MS\ncampus/GSDM\ncampy/RT\ncamshaft/SM\ncan't\ncan/MDRSZGJ\ncanal/SGMD\ncanalization/MS\ncanalize/GSD\ncanap/S\ncanard/MS\ncanary/SM\ncanasta/SM\ncancan/SM\ncancel/RDZGS\ncancelate/D\ncanceled/U\ncanceler/M\ncancellation/MS\ncancer/MS\ncancerous/Y\ncandelabra/S\ncandelabrum/M\ncandid/TRYPS\ncandidacy/MS\ncandidate/SM\ncandidature/S\ncandidly/U\ncandidness/SM\ncandle/GMZRSD\ncandlelight/SMR\ncandlelit\ncandlepower/SM\ncandler/M\ncandlestick/SM\ncandlewick/MS\ncandor/MS\ncandy/GSDM\ncane/SM\ncanebrake/SM\ncaner/M\ncanine/S\ncaning/M\ncanister/SGMD\ncanker/SDMG\ncankerous\ncannabis/MS\ncanned\ncannelloni\ncanner/SM\ncannery/MS\ncannibal/SM\ncannibalism/MS\ncannibalistic\ncannibalization/SM\ncannibalize/GSD\ncannily/U\ncanniness/UM\ncanninesses\ncanning/M\ncannister/SM\ncannon/SDMG\ncannonade/SDGM\ncannonball/SGDM\ncannot\ncanny/RPUT\ncanoe/DSGM\ncanoeist/SM\ncanon/SM\ncanonic\ncanonical/SY\ncanonicalization\ncanonicalize/GSD\ncanonist/M\ncanonization/MS\ncanonize/SDG\ncanonized/U\ncanopy/GSDM\ncanst\ncant's\ncant/CZGSRD\ncantabile/S\ncantaloupe/MS\ncantankerous/PY\ncantankerousness/SM\ncantata/SM\ncanted/IA\ncanteen/MS\ncanter/CM\ncantered\ncantering\ncanticle/SM\ncantilever/SDMG\ncanto/MS\ncanton/MGSLD\ncantonal\ncantonment/SM\ncantor/MS\ncants/A\ncanvas/RSDMG\ncanvasback/MS\ncanvass/RSDZG\ncanvasser/M\ncanyon/MS\ncap/MDRSZB\ncapability/ISM\ncapable/PI\ncapableness/IM\ncapabler\ncapablest\ncapably/I\ncapacious/PY\ncapaciousness/MS\ncapacitance/SM\ncapacitate/V\ncapacitive/Y\ncapacitor/MS\ncapacity/IMS\ncaparison/SDMG\ncape/SM\ncaper/GDM\ncapeskin/SM\ncapillarity/MS\ncapillary/S\ncapita/M\ncapital/SMY\ncapitalism/SM\ncapitalist/SM\ncapitalistic\ncapitalistically\ncapitalization/SMA\ncapitalize/RSDGZ\ncapitalized/AU\ncapitalizer/M\ncapitalizes/A\ncapitation/CSM\ncapitol/SM\ncapitulate/AXNGSD\ncapitulation/MA\ncaplet/S\ncapo/SM\ncapon/SM\ncapped/UA\ncapping/M\ncappuccino/MS\ncaprice/MS\ncapricious/PY\ncapriciousness/MS\ncaps/AU\ncapsicum/MS\ncapsize/SDG\ncapstan/MS\ncapstone/MS\ncapsular\ncapsule/MGSD\ncapsulize/GSD\ncapt/V\ncaptain/SGDM\ncaptaincy/MS\ncaption/GSDRM\ncaptious/PY\ncaptiousness/SM\ncaptivate/XGNSD\ncaptivation/M\ncaptivator/SM\ncaptive/MS\ncaptivity/SM\ncaptor/SM\ncapture/AGSD\ncapturer/MS\ncar/ZGSMDR\ncaracul's\ncarafe/SM\ncaramel/MS\ncaramelize/SDG\ncarapace/SM\ncarapaxes\ncarat/SM\ncaravan/DRMGS\ncaravaner/M\ncaravansary/MS\ncaravanserai's\ncaravel/MS\ncaraway/MS\ncarbide/MS\ncarbine/MS\ncarbohydrate/MS\ncarbolic\ncarbon/MS\ncarbonaceous\ncarbonate/SDXMNG\ncarbonation/M\ncarbonic\ncarboniferous\ncarbonization/SAM\ncarbonize/ZGRSD\ncarbonizer's\ncarbonizer/AS\ncarbonizes/A\ncarbonyl/M\ncarborundum\ncarboy/MS\ncarbuncle/SDM\ncarbuncular\ncarburetor/MS\ncarburetter/S\ncarburettor/SM\ncarcase/MS\ncarcass/SM\ncarcinogen/SM\ncarcinogenic\ncarcinogenicity/MS\ncarcinoma/SM\ncard's\ncard/EDRSG\ncardamom/MS\ncardboard/MS\ncarder's/E\ncarder/MS\ncardholders\ncardiac/S\ncardigan/SM\ncardinal/SYM\ncardinality/SM\ncarding/M\ncardiogram/MS\ncardiograph/M\ncardiographs\ncardioid/M\ncardiologist/SM\ncardiology/MS\ncardiomegaly/M\ncardiopulmonary\ncardiovascular\ncardsharp/ZSMR\ncare/S\ncared/U\ncareen/DSG\ncareer/SGRDM\ncareerism/M\ncareerist/MS\ncarefree\ncareful/PY\ncarefuller\ncarefullest\ncarefulness/MS\ncaregiver/S\ncareless/YP\ncarelessness/MS\ncarer/M\ncaress/SRDMVG\ncaresser/M\ncaressing/Y\ncaressive/Y\ncaret/SM\ncaretaker/SM\ncareworn\ncarfare/MS\ncargo/M\ncargoes\ncarhop/SM\ncarhopped\ncarhopping\ncaribou/MS\ncaricature/GMSD\ncaricaturisation\ncaricaturist/MS\ncaricaturization\ncaries/M\ncarillon/SM\ncarillonned\ncarillonning\ncaring/U\ncarious\ncarjack/GSJDRZ\ncarload/MSG\ncarmine/MS\ncarnage/MS\ncarnal/Y\ncarnality/SM\ncarnation/IMS\ncarnelian/SM\ncarney's\ncarnival/MS\ncarnivore/SM\ncarnivorous/YP\ncarnivorousness/MS\ncarny/SDG\ncarob/SM\ncarol/SGZMRD\ncaroler/M\ncarom/GSMD\ncarotene/MS\ncarotid/MS\ncarousal/MS\ncarouse/SRDZG\ncarousel/MS\ncarouser/M\ncarp/MDRSGZ\ncarpal/SM\ncarpel/SM\ncarpenter/DSMG\ncarpentering/M\ncarpentry/MS\ncarper/M\ncarpet/MDJGS\ncarpetbag/MS\ncarpetbagged\ncarpetbagger/MS\ncarpetbagging\ncarpeting/M\ncarpi/M\ncarping/Y\ncarpool/DGS\ncarport/MS\ncarpus/M\ncarrageen/M\ncarrel/SM\ncarriage/SM\ncarriageway/SM\ncarrier/M\ncarrion/SM\ncarrot/MS\ncarroty/RT\ncarrousel's\ncarry/RSDZG\ncarryall/MS\ncarryout/S\ncarryover/S\ncarsick/P\ncarsickness/SM\ncart/MDRGSZ\ncartage/MS\ncarte/M\ncartel/SM\ncarter/M\ncarthorse/MS\ncartilage/MS\ncartilaginous\ncartload/MS\ncartographer/MS\ncartographic\ncartography/MS\ncarton/GSDM\ncartoon/GSDM\ncartoonist/MS\ncartridge/SM\ncartwheel/MRDGS\ncarve/DSRJGZ\ncarven\ncarver/M\ncarving/M\ncaryatid/MS\ncasaba/SM\ncasbah/M\ncascade/MSDG\ncascara/MS\ncase/DSJMGL\ncasebook/SM\ncased/U\ncaseharden/SGD\ncasein/SM\ncaseload/MS\ncasement/SM\ncasework/ZMRS\ncaseworker/M\ncash/GZMDSR\ncashbook/SM\ncashew/MS\ncashier/SDMG\ncashless\ncashmere/MS\ncasing/M\ncasino/MS\ncask/GSDM\ncasket/SGMD\ncassava/MS\ncasserole/MGSD\ncassette/SM\ncassia/MS\ncassino's\ncassock/SDM\ncassowary/SM\ncast/GZSJMDR\ncastanet/SM\ncastaway/SM\ncaste/MHS\ncastellated\ncaster/M\ncastigate/XGNSD\ncastigation/M\ncastigator/SM\ncasting/M\ncastle/GMSD\ncastoff/S\ncastor's\ncastrate/DSNGX\ncastration/M\ncasts/A\ncasual/SYP\ncasualness/SM\ncasualty/SM\ncasuist/MS\ncasuistic\ncasuistry/SM\ncat/SMRZ\ncataclysm/MS\ncataclysmal\ncataclysmic\ncatacomb/MS\ncatafalque/SM\ncatalepsy/MS\ncataleptic/S\ncatalog/SDRMZG\ncataloger/M\ncatalpa/SM\ncatalysis/M\ncatalyst/SM\ncatalytic\ncatalytically\ncatalyze/DSG\ncatamaran/MS\ncatapult/MGSD\ncataract/MS\ncatarrh/M\ncatarrhs\ncatastrophe/SM\ncatastrophic\ncatastrophically\ncatatonia/MS\ncatatonic/S\ncatbird/MS\ncatboat/SM\ncatcall/SMDG\ncatch/BRSJLGZ\ncatchable/U\ncatchall/MS\ncatcher/M\ncatchment/SM\ncatchpenny/S\ncatchphrase/S\ncatchup/MS\ncatchword/MS\ncatchy/TR\ncatechism/MS\ncatechist/SM\ncatechize/SDG\ncatecholamine/MS\ncategoric\ncategorical/Y\ncategorization/MS\ncategorize/RSDGZ\ncategorized/AU\ncategory/MS\ncatenate/NF\ncatenation/MF\ncater/GRDZ\ncatercorner\ncaterer/M\ncatering/M\ncaterpillar/SM\ncaterwaul/DSG\ncatfish/MS\ncatgut/SM\ncatharses\ncatharsis/M\ncathartic/S\ncathedral/SM\ncatheter/SM\ncatheterize/GSD\ncathode/MS\ncathodic\ncatholic/MS\ncatholicism\ncatholicity/MS\ncation/MS\ncationic\ncatkin/SM\ncatlike\ncatnap/SM\ncatnapped\ncatnapping\ncatnip/MS\ncatsup's\ncattail/SM\ncatted\ncattery/M\ncattily\ncattiness/SM\ncatting\ncattle/M\ncattleman/M\ncattlemen\ncatty/PRST\ncatwalk/MS\ncaucus/SDMG\ncaudal/Y\ncaught/U\ncauldron/MS\ncauliflower/MS\ncaulk/JSGZRD\ncaulker/M\ncausal/YS\ncausality/SM\ncausate/XVN\ncausation/M\ncausative/SY\ncause/DSRGMZ\ncaused/U\ncauseless\ncauser/M\ncauserie/MS\ncauseway/SGDM\ncaustic/YS\ncaustically\ncausticity/MS\ncauterization/SM\ncauterize/GSD\ncauterized/U\ncaution/GJDRMSZ\ncautionary\ncautioner/M\ncautious/PIY\ncautiousness's/I\ncautiousness/SM\ncavalcade/MS\ncavalier/SGYDP\ncavalierness/M\ncavalry/MS\ncavalryman/M\ncavalrymen\ncave's\ncave/GFRSD\ncaveat/SM\ncaveatted\ncaveatting\ncaveman/M\ncavemen\ncaver/M\ncavern/GSDM\ncavernous/Y\ncaviar/MS\ncavil/SJRDGZ\ncaviler/M\ncaving/MS\ncavity/MFS\ncavort/SDG\ncaw/SMDG\ncay's\ncay/SC\ncayenne/SM\ncayman/SM\ncayuse/SM\ncc\ncease/DSCG\nceasefire/S\nceaseless/YP\nceaselessness/SM\nceasing/U\nceca\ncecal\ncecum/M\ncedar/SM\ncede/FRSDG\nceded/A\nceder's/F\nceder/SM\ncedes/A\ncedilla/SM\nceding/A\nceilidh/M\nceiling/MDS\ncelandine/MS\ncelebrant/MS\ncelebrate/XSDGN\ncelebrated/P\ncelebratedness/M\ncelebration/M\ncelebrator/MS\ncelebratory\ncelebrity/MS\ncelerity/SM\ncelery/SM\ncelesta/SM\ncelestial/YS\ncelibacy/MS\ncelibate/SM\ncell/GMDS\ncellar/RDMGS\ncellarer/M\ncellist/SM\ncello/MS\ncellophane/SM\ncellphone/S\ncellular/SY\ncellulite/S\ncelluloid/SM\ncellulose/SM\ncement/ZGMRDS\ncementa\ncementer/M\ncementum/SM\ncemetery/MS\ncenobite/MS\ncenobitic\ncenotaph/M\ncenotaphs\ncenser/MS\ncensor/GDMS\ncensored/U\ncensorial\ncensorious/YP\ncensoriousness/MS\ncensorship/MS\ncensure/BRSDZMG\ncensurer/M\ncensus/SDMG\ncent/SZMR\ncentaur/SM\ncentavo/SM\ncentenarian/MS\ncentenary/S\ncentennial/YS\ncenter's\ncenter/AC\ncenterboard/SM\ncentered\ncenterer/S\ncenterfold/S\ncentering/SM\ncenterline/SM\ncenterpiece/SM\ncentigrade/S\ncentigram/SM\ncentiliter/MS\ncentime/SM\ncentimeter/SM\ncentipede/MS\ncentral/STRY\ncentralism/M\ncentralist/M\ncentrality/MS\ncentralization/CAMS\ncentralize/CGSD\ncentralizer/SM\ncentralizes/A\ncentrefold's\ncentric/F\ncentrifugal/SY\ncentrifugate/NM\ncentrifugation/M\ncentrifuge/GMSD\ncentripetal/Y\ncentrist/MS\ncentroid/MS\ncenturion/MS\ncentury/MS\ncephalic/S\nceramic/MS\nceramicist/S\nceramist/MS\ncerate/MD\ncereal/MS\ncerebellar\ncerebellum/MS\ncerebra\ncerebral/SY\ncerebrate/XSDGN\ncerebration/M\ncerebrum/MS\ncerement/SM\nceremonial/YSP\nceremonious/YUP\nceremoniousness's/U\nceremoniousness/MS\nceremony/MS\ncerise/SM\ncerium/MS\ncermet/SM\ncert/FS\ncertain/UY\ncertainer\ncertainest\ncertainty/UMS\ncertifiable\ncertifiably\ncertificate/SDGM\ncertification/AMC\ncertified/U\ncertifier/M\ncertify/DRSZGNX\ncertiorari/M\ncertitude/ISM\ncerulean/MS\ncervical\ncervices/M\ncervix/M\ncesarean/S\ncesium/MS\ncessation/SM\ncession/FAMSK\ncesspit/M\ncesspool/SM\ncetacean/S\ncetera/S\ncf\ncg\nch/VT\nchafe/GDSR\nchafer/M\nchaff/GRDMS\nchaffer/DRG\nchafferer/M\nchaffinch/SM\nchagrin/DGMS\nchain's\nchain/SGUD\nchainlike\nchainsaw/SGD\nchair/SGDM\nchairlady/M\nchairlift/MS\nchairman/MDGS\nchairmanship/MS\nchairmen\nchairperson/MS\nchairwoman/M\nchairwomen\nchaise/SM\nchalcedony/MS\nchalet/SM\nchalice/DSM\nchalk/DSMG\nchalkboard/SM\nchalkiness/S\nchalkline\nchalky/RPT\nchallenge/ZGSRD\nchallenged/U\nchallenger/M\nchallenging/Y\nchallis/SM\nchamber/SZGDRM\nchamberer/M\nchamberlain/MS\nchambermaid/MS\nchamberpot/S\nchambray/MS\nchameleon/SM\nchamfer/DMGS\nchammy's\nchamois/DSMG\nchamomile/MS\nchamp/DGSZ\nchampagne/MS\nchampaign/M\nchampion/MDGS\nchampionship/MS\nchance/GMRSD\nchanced/M\nchancel/SM\nchancellery/SM\nchancellor/SM\nchancellorship/SM\nchancery/SM\nchanciness/S\nchancing/M\nchancre/SM\nchancy/RPT\nchandelier/SM\nchandler/MS\nchange/GZRSD\nchangeabilities\nchangeability/UM\nchangeable/U\nchangeableness/SM\nchangeably/U\nchanged/U\nchangeless\nchangeling/M\nchangeover/SM\nchanger/M\nchanging/U\nchannel/MDRZSG\nchanneler/M\nchanneling/M\nchannelization/SM\nchannelize/GDS\nchannellings\nchanson/SM\nchant/SJGZMRD\nchanter/M\nchanteuse/MS\nchantey/SM\nchanticleer/SM\nchantry/MS\nchanty's\nchaos/SM\nchaotic\nchaotically\nchap/MS\nchaparral/MS\nchapbook/SM\nchapeau/MS\nchapel/MS\nchaperon/GMDS\nchaperonage/MS\nchaperone's\nchaperoned/U\nchaplain/MS\nchaplaincy/MS\nchaplet/SM\nchapped\nchapping\nchapter/SGDM\nchar/GS\ncharabanc/MS\ncharacter/MDSG\ncharacterful\ncharacteristic/SM\ncharacteristically/U\ncharacterizable/MS\ncharacterization/MS\ncharacterize/DRSBZG\ncharacterized/U\ncharacterizer/M\ncharacterless\ncharade/SM\ncharbroil/SDG\ncharcoal/MGSD\nchard/SM\nchardonnay/S\ncharge/EGRSDA\nchargeable/P\nchargeableness/M\ncharged/U\ncharger/AME\nchargers\ncharily\nchariness/MS\nchariot/SMDG\ncharioteer/GSDM\ncharisma/M\ncharismata\ncharismatic/S\ncharismatically\ncharitable/UP\ncharitableness/UM\ncharitablenesses\ncharitably/U\ncharity/MS\ncharlady/M\ncharlatan/SM\ncharlatanism/MS\ncharlatanry/SM\ncharm/SGMZRD\ncharmer/M\ncharming/RYT\ncharmless\ncharred\ncharring\nchart/SJMRDGBZ\ncharted/U\ncharter's\ncharter/AGDS\nchartered/U\ncharterer/SM\nchartist/SM\nchartreuse/MS\nchartroom/S\ncharwoman/M\ncharwomen\nchary/PTR\nchase/DSRGZ\nchaser/M\nchasing/M\nchasm/SM\nchassis/M\nchaste/UTR\nchastely\nchasten/GSD\nchasteness/SM\nchastise/ZGLDRS\nchastisement/SM\nchastiser/M\nchastity's/U\nchastity/SM\nchasuble/SM\nchat/MS\nchateaus\nchatted\nchattel/MS\nchatter/SZGDRY\nchatterbox/MS\nchatterer/M\nchattily\nchattiness/SM\nchatting\nchatty/RTP\nchauffeur/GSMD\nchauvinism/MS\nchauvinist/MS\nchauvinistic\nchauvinistically\nchaw\ncheap/YRNTXSP\ncheapen/DG\ncheapish\ncheapness/MS\ncheapskate/MS\ncheat/RDSGZ\ncheater/M\ncheck's/A\ncheck/GZBSRDM\ncheckable/U\ncheckbook/MS\nchecked/UA\nchecker/DMG\ncheckerboard/MS\nchecklist/S\ncheckmate/MSDG\ncheckoff/SM\ncheckout/S\ncheckpoint/MS\ncheckroom/MS\nchecks/A\nchecksum/SM\nchecksummed\nchecksumming\ncheckup/MS\ncheddar/S\ncheek/DMGS\ncheekbone/SM\ncheekily\ncheekiness/SM\ncheeky/PRT\ncheep/GMDS\ncheer/YRDGZS\ncheerer/M\ncheerful/YP\ncheerfuller\ncheerfullest\ncheerfulness/MS\ncheerily\ncheeriness/SM\ncheerio/S\ncheerleader/SM\ncheerless/PY\ncheerlessness/SM\ncheers/S\ncheery/PTR\ncheese/SDGM\ncheeseburger/SM\ncheesecake/SM\ncheesecloth/M\ncheesecloths\ncheeseparing/S\ncheesiness/SM\ncheesy/PRT\ncheetah/M\ncheetahs\nchef/SM\ncheffed\ncheffing\nchelate/XDMNG\nchelation/M\nchem\nchemic\nchemical/SYM\nchemiluminescence/M\nchemiluminescent\nchemise/SM\nchemist/SM\nchemistry/SM\nchemotherapeutic/S\nchemotherapy/SM\nchemurgy/SM\nchenille/SM\ncherish/GDRS\ncherisher/M\ncheroot/MS\ncherry/SM\nchert/MS\ncherub/SM\ncherubic\ncherubim/S\nchervil/MS\nchess/SM\nchessboard/SM\nchessman/M\nchessmen\nchest/MRDS\nchesterfield/MS\nchestful/S\nchestnut/SM\nchesty/TR\nchevalier/SM\ncheviot/S\nchevron/DMS\nchew/GZSDR\nchewer/M\nchewiness/S\nchewy/RTP\nchg\nchge\nchi/MS\nchianti/M\nchiaroscuro/SM\nchic/SYRPT\nchicane/MGDS\nchicanery/MS\nchichi/RTS\nchick/XSNM\nchickadee/SM\nchicken/GDM\nchickenfeed\nchickenhearted\nchickenpox/MS\nchickpea/MS\nchickweed/MS\nchicle/MS\nchicness/S\nchicory/MS\nchide/GDS\nchiding/Y\nchief/YRMST\nchiefdom/MS\nchieftain/SM\nchiffon/MS\nchiffonier/MS\nchigger/MS\nchignon/MS\nchihuahua/S\nchilblain/MS\nchild/GMYD\nchildbearing/MS\nchildbirth/M\nchildbirths\nchildcare/S\nchildes\nchildhood/MS\nchildish/YP\nchildishness/SM\nchildless/P\nchildlessness/SM\nchildlike/P\nchildlikeness/M\nchildminders\nchildproof/GSD\nchildrearing\nchildren/M\nchile's\nchili/M\nchilies\nchill/MRDJGTZPS\nchiller/M\nchilli's\nchilliness/MS\nchilling/Y\nchillness/MS\nchilly/TPRS\nchimaera's\nchimaerical\nchime/DSRGMZ\nchimer/M\nchimera/SM\nchimeric\nchimerical\nchimney/SMD\nchimp/MS\nchimpanzee/SM\nchin/SGDM\nchina/MS\nchinchilla/SM\nchine/MS\nchink/DMSG\nchinless\nchinned\nchinner/S\nchinning\nchino/MS\nchinstrap/S\nchintz/SM\nchintzy/TR\nchip/SM\nchipboard/M\nchipmunk/SM\nchipped\nchipper/DGS\nchipping/MS\nchiral\nchirography/SM\nchiropodist/SM\nchiropody/MS\nchiropractic/MS\nchiropractor/SM\nchirp/GDS\nchirpy/RT\nchirrup/DGS\nchisel/ZGSJMDR\nchiseler/M\nchit/SM\nchitchat/SM\nchitchatted\nchitchatting\nchitin/SM\nchitinous\nchitterlings\nchivalric\nchivalrous/YP\nchivalrously/U\nchivalrousness/MS\nchivalry/SM\nchive/GMDS\nchivvy/D\nchivying\nchlamydia/S\nchlamydiae\nchloral/MS\nchlorate/M\nchlordane/MS\nchloride/MS\nchlorinate/XDSGN\nchlorinated/C\nchlorinates/C\nchlorination/M\nchlorine/MS\nchlorofluorocarbon/S\nchloroform/DMSG\nchlorophyll/SM\nchloroplast/MS\nchloroquine/M\nchm\nchock/SGRDM\nchockablock\nchocoholic/S\nchocolate/MS\nchocolaty\nchoice/RSMTYP\nchoiceness/M\nchoir/SDMG\nchoirboy/MS\nchoirmaster/SM\nchoke/DSRGZ\nchokeberry/M\nchokecherry/SM\nchoker/M\nchokes/M\nchoking/Y\ncholer/SM\ncholera/SM\ncholeric\ncholesterol/SM\ncholine/M\ncholinesterase/M\nchomp/DSG\nchoose/GZRS\nchooser/M\nchoosiness/S\nchoosy/RPT\nchop/S\nchophouse/SM\nchopped\nchopper/SDMG\nchoppily\nchoppiness/MS\nchopping\nchoppy/RPT\nchopstick/SM\nchoral/SY\nchorale/MS\nchord/SGMD\nchordal\nchordata\nchordate/MS\nchording/M\nchore/DSGNM\nchorea/MS\nchoreograph/ZGDR\nchoreographer/M\nchoreographic\nchoreographically\nchoreographs\nchoreography/MS\nchorines\nchorion/M\nchorister/SM\nchoroid/S\nchortle/ZGDRS\nchortler/M\nchorus/GDSM\nchose/S\nchosen/U\nchow/DGMS\nchowder/SGDM\nchrism/SM\nchrissake\nchristen/SAGD\nchristened/U\nchristening/SM\nchroma/M\nchromate/M\nchromatic/PS\nchromatically\nchromaticism/M\nchromaticness/M\nchromatics/M\nchromatin/MS\nchromatogram/MS\nchromatograph\nchromatographic\nchromatography/M\nchrome/GMSD\nchromic\nchromite/M\nchromium/SM\nchromosomal\nchromosome/MS\nchromosphere/M\nchronic/S\nchronically\nchronicle/SRDMZG\nchronicled/U\nchronicler/M\nchronograph/M\nchronographs\nchronography\nchronological/Y\nchronologist/MS\nchronology/MS\nchronometer/MS\nchronometric\nchrysalids\nchrysalis/SM\nchrysanthemum/MS\nchub/MS\nchubbiness/SM\nchubby/RTP\nchuck/GSDM\nchuckhole/SM\nchuckle/DSG\nchuckling/Y\nchuff/DM\nchug/MS\nchugged\nchugging\nchukka/S\nchum/MS\nchummed\nchummily\nchumminess/MS\nchumming\nchummy/SRTP\nchump/MDGS\nchumping/M\nchunk/SGDM\nchunkiness/MS\nchunky/RPT\nchuntering\nchurch/MDSYG\nchurchgoer/SM\nchurchgoing/SM\nchurchliness/M\nchurchly/P\nchurchman/M\nchurchmen\nchurchwarden/SM\nchurchwoman/M\nchurchwomen\nchurchyard/SM\nchurl/SM\nchurlish/YP\nchurlishness/SM\nchurn/SGZRDM\nchurner/M\nchurning/M\nchute/DSGM\nchutney/MS\nchutzpa/SM\nchutzpah/M\nchutzpahs\nchyme/SM\nchteau/M\nchteaux\nchtelaine/SM\nciao/S\ncicada/MS\ncicatrice/S\ncicatrix's\ncicerone/MS\nciceroni\ncider's/C\ncider/SM\ncigar/SM\ncigarette/MS\ncigarillo/MS\ncilantro/S\ncilia/M\nciliate/FDS\nciliately\ncilium/M\ncinch/MSDG\ncinchona/SM\ncincture/MGSD\ncinder/DMGS\ncine/M\ncinema/SM\ncinematic\ncinematographer/MS\ncinematographic\ncinematography/MS\ncinnabar/MS\ncinnamon/MS\ncipher/MSGD\nciphered/C\nciphers/C\ncir\ncirca\ncircadian\ncircle/RSDGM\ncircler/M\ncirclet/MS\ncircuit/GSMD\ncircuital\ncircuitous/YP\ncircuitousness/MS\ncircuitry/SM\ncircuity/MS\ncirculant\ncircular/PSMY\ncircularity/SM\ncircularize/GSD\ncircularness/M\ncirculate/ASDNG\ncirculation/MA\ncirculations\ncirculative\ncirculatory\ncircumcise/DRSXNG\ncircumcised/U\ncircumciser/M\ncircumcision/M\ncircumference/SM\ncircumferential/Y\ncircumflex/MSDG\ncircumlocution/MS\ncircumlocutory\ncircumnavigate/DSNGX\ncircumnavigation/M\ncircumnavigational\ncircumpolar\ncircumscribe/GSD\ncircumscription/SM\ncircumspect/Y\ncircumspection/SM\ncircumsphere\ncircumstance/SDMG\ncircumstantial/YS\ncircumvent/SBGD\ncircumvention/MS\ncircus/SM\ncirque/SM\ncirrhoses\ncirrhosis/M\ncirrhotic/S\ncirri/M\ncirrus/M\ncistern/SM\ncit/DSG\ncitadel/SM\ncitation/SMA\ncitations/I\ncite/ISDAG\ncitified\ncitizen/SYM\ncitizenry/SM\ncitizenship/MS\ncitrate/DM\ncitric\ncitron/MS\ncitronella/MS\ncitrus/SM\ncity/DSM\ncityscape/MS\ncitywide\ncivet/SM\ncivic/S\ncivics/M\ncivil/UY\ncivilian/SM\ncivility/IMS\ncivilization/AMS\ncivilizational/MS\ncivilize/DRSZG\ncivilized/PU\ncivilizedness/M\ncivilizer/M\ncivilizes/AU\ncivvies\nck/C\ncl/GJ\nclack/SDG\nclad/U\ncladding/SM\nclads\nclaim/CDRSKAEGZ\nclaimable\nclaimant/MS\nclaimed/U\nclaimer/KMACE\nclairvoyance/MS\nclairvoyant/YS\nclam/MS\nclambake/MS\nclamber/SDRZG\nclamberer/M\nclammed\nclammily\nclamminess/MS\nclamming\nclammy/TPR\nclamor/GDRMSZ\nclamorer/M\nclamorous/PUY\nclamorousness/UM\nclamp/MRDGS\nclampdown/SM\nclamper/M\nclamshell/MS\nclan/MS\nclandestine/YP\nclandestineness/M\nclang/SGZRD\nclanger/M\nclangor/MDSG\nclangorous/Y\nclank/SGDM\nclanking/Y\nclannish/PY\nclannishness/SM\nclansman/M\nclansmen\nclap/S\nclapboard/SDGM\nclapped\nclapper/GMDS\nclapping\nclaptrap/SM\nclaque/MS\nclaret/MDGS\nclarification/M\nclarifier/M\nclarify/NGXDRS\nclarinet/SM\nclarinetist/SM\nclarinettist's\nclarion/GSMD\nclarities\nclarity/UM\nclash/RSDG\nclasher/M\nclasp's\nclasp/UGSD\nclasped/M\nclasper/M\nclass/GRSDM\nclasser/M\nclassic/S\nclassical/Y\nclassicism/SM\nclassicist/SM\nclassics/M\nclassifiable/U\nclassification/AMC\nclassificatory\nclassified/S\nclassifier/SM\nclassify/CNXASDG\nclassiness/SM\nclassless/P\nclassmate/MS\nclassroom/MS\nclasswork/M\nclassy/PRT\nclatter/SGDR\nclatterer/M\nclattering/Y\nclattery\nclausal\nclause/MS\nclaustrophobia/SM\nclaustrophobic\nclave's/F\nclave/RM\nclavichord/SM\nclavicle/MS\nclavier/MS\nclaw/GDRMS\nclawer/M\nclay/MDGS\nclayey\nclayier\nclayiest\nclaymore/MS\nclean/UYRDPT\ncleanable\ncleaner/MS\ncleaning/SM\ncleanliness/UMS\ncleanly/PRTU\ncleanness/MSU\ncleans/GDRSZ\ncleanse\ncleanser/M\ncleanup/MS\nclear/UTRD\nclearance/MS\nclearcut\nclearer/M\nclearheaded/PY\nclearheadedness/M\nclearing/MS\nclearinghouse/S\nclearly\nclearness/MS\nclears\nclearway/M\ncleat/MDSG\ncleavage/MS\ncleave/RSDGZ\ncleaver/M\nclef/SM\ncleft/MDGS\nclematis/MS\nclemence\nclemency/ISM\nclement/IY\nclements\nclench/UD\nclenches\nclenching\nclerestory/MS\nclergy/MS\nclergyman/M\nclergymen\nclergywoman\nclergywomen\ncleric/SM\nclerical/YS\nclericalism/SM\nclerk/SGYDM\nclerkship/MS\nclever/RYPT\ncleverness/SM\nclevis/SM\nclew/DMGS\nclich/SM\nclichd\nclick/GZSRDM\nclicker/M\nclient/SM\nclientle/SM\ncliff/SM\ncliffhanger/MS\ncliffhanging\nclimacteric/SM\nclimactic\nclimate/MS\nclimatic\nclimatically\nclimatological/Y\nclimatologist/SM\nclimatology/MS\nclimax/MDSG\nclimb/BGZSJRD\nclimbable/U\nclimbdown\nclimbed/U\nclimber/M\nclime/SM\nclinch/DRSZG\nclincher/M\nclinching/Y\ncling/U\nclinger/MS\nclinging\nclingy/TR\nclinic/MS\nclinical/Y\nclinician/MS\nclink/RDGSZ\nclinker/GMD\nclinometer/MIS\ncliometric/S\ncliometrician/S\nclip/SM\nclipboard/SM\nclipped/U\nclipper/MS\nclipping/SM\nclique/SDGM\ncliquey\ncliquier\ncliquiest\ncliquish/YP\ncliquishness/SM\nclitoral\nclitorides\nclitoris/MS\ncloaca/M\ncloacae\ncloak's\ncloak/USDG\ncloakroom/MS\nclobber/DGS\ncloche/MS\nclock/SGZRDMJ\nclocker/M\nclockmaker/M\nclockwatcher\nclockwise\nclockwork/MS\nclod/MS\nclodded\nclodding\ncloddish/P\ncloddishness/M\nclodhopper/SM\nclog's\nclog/US\nclogged/U\nclogging/U\ncloisonnes\ncloisonn\ncloister/MDGS\ncloistral\nclomp/MDSG\nclonal\nclone/DSRGMZ\nclonk/SGD\nclop/S\nclopped\nclopping\nclose/EDSRG\nclosed/U\nclosefisted\nclosely\nclosemouthed\ncloseness/MS\ncloseout/MS\ncloser/EM\nclosers\nclosest\ncloset/MDSG\ncloseup/S\nclosing/S\nclosure's/I\nclosure/EMS\nclosured\nclosuring\nclot/MS\ncloth/GJMSD\nclothbound\nclothe/UDSG\nclothesbrush\nclotheshorse/MS\nclothesline/SDGM\nclothesman\nclothesmen\nclothespin/MS\nclothier/MS\nclothing/M\ncloths\nclotted\nclotting\ncloture/MDSG\ncloud/SGMD\ncloudburst/MS\nclouded/U\ncloudiness/SM\ncloudless/YP\ncloudlessness/M\ncloudscape/SM\ncloudy/TPR\nclout/GSMD\nclove/SRMZ\ncloven\nclover/M\ncloverleaf/MS\nclown/DMSG\nclownish/PY\nclownishness/SM\ncloy/DSG\ncloying/Y\nclub/MS\nclubbed/M\nclubbing/M\nclubfeet\nclubfoot/DM\nclubhouse/SM\nclubroom/SM\ncluck/GSDM\nclue/MGDS\nclueless\nclump/MDGS\nclumpy/RT\nclumsily\nclumsiness/MS\nclumsy/PRT\nclung\nclunk/SGZRDM\nclunky/PRYT\ncluster/SGJMD\nclustered/AU\nclusters/A\nclutch/DSG\nclutter/GSD\ncluttered/U\ncm\ncnidarian/MS\ncnt\nco/DES\ncoach/MSRDG\ncoacher/M\ncoachman/M\ncoachmen\ncoachwork/M\ncoadjutor/MS\ncoagulable\ncoagulant/SM\ncoagulate/GNXSD\ncoagulation/M\ncoagulator/S\ncoal/MDRGS\ncoaler/M\ncoalesce/GDS\ncoalescence/SM\ncoalescent\ncoalface/SM\ncoalfield/MS\ncoalition/MS\ncoalitionist/SM\ncoalminers\ncoarse/TYRP\ncoarsen/SGD\ncoarseness/SM\ncoast/SMRDGZ\ncoastal\ncoaster/M\ncoastguard/MS\ncoastline/SM\ncoat/MDRGZJS\ncoated/U\ncoating/M\ncoattail/S\ncoattest\ncoauthor/MDGS\ncoax/GZDSR\ncoaxer/M\ncoaxial/Y\ncoaxing/Y\ncob/SM\ncobalt/MS\ncobbed\ncobbing\ncobble/SRDGMZ\ncobbler/M\ncobblestone/MSD\ncoble/M\ncobra/MS\ncobweb/SM\ncobwebbed\ncobwebbing\ncobwebby/RT\ncoca/MS\ncocaine/MS\ncocci/MS\ncoccus/M\ncoccyges\ncoccyx/M\ncochineal/SM\ncochlea/SM\ncochleae\ncochlear\ncock/GDRMS\ncockade/SM\ncockamamie\ncockatoo/SM\ncockatrice/MS\ncockcrow/MS\ncocker/M\ncockerel/MS\ncockeye/DM\ncockeyed/PY\ncockfight/MJSG\ncockfighting/M\ncockily\ncockiness/MS\ncockle/SDGM\ncocklebur/M\ncockleshell/SM\ncockney/MS\ncockpit/MS\ncockroach/SM\ncockscomb/SM\ncockshies\ncocksucker/S!\ncocksure\ncocktail/GDMS\ncocky/RPT\ncoco/MS\ncocoa/SM\ncoconut/SM\ncocoon/GDMS\ncod/MDRSZGJ\ncoda/SM\ncodded\ncodding\ncoddle/GSRD\ncoddler/M\ncode's\ncode/SCZGJRD\ncodebook/S\ncodebreak/R\ncoded/UA\ncodeine/MS\ncodename/D\ncodependency/S\ncodependent/S\ncoder/CM\ncodes/A\ncodetermine/S\ncodeword/SM\ncodex/M\ncodfish/SM\ncodger/MS\ncodices/M\ncodicil/SM\ncodification/M\ncodifier/M\ncodify/NZXGRSD\ncoding/M\ncodling/M\ncodpiece/MS\ncoed/SM\ncoedited\ncoediting\ncoeditor/MS\ncoedits\ncoeducation/SM\ncoeducational\ncoefficient/SYM\ncoelenterate/MS\ncoequal/SY\ncoerce/SRDXVGNZ\ncoercer/M\ncoercible/I\ncoercion/M\ncoercive/PY\ncoerciveness/M\ncoeval/YS\ncoexist/GDS\ncoexistence/MS\ncoexistent\ncoextensive/Y\ncofactor/MS\ncoffee/SM\ncoffeecake/SM\ncoffeecup\ncoffeehouse/SM\ncoffeemaker/S\ncoffeepot/MS\ncoffer/DMSG\ncofferdam/SM\ncoffin/DMGS\ncog/MS\ncogency/MS\ncogent/Y\ncogged\ncogging\ncogitate/DSXNGV\ncogitation/M\ncogitator/MS\ncognac/SM\ncognate/SXYN\ncognation/M\ncognition/SAM\ncognitional\ncognitive/SY\ncognizable\ncognizance/MAI\ncognizances/A\ncognizant/I\ncognomen/SM\ncognoscente\ncognoscenti\ncogwheel/SM\ncohabit/SDG\ncohabitant/MS\ncohabitation/SM\ncohabitational\ncoheir/MS\ncohere/GSRD\ncoherence/SIM\ncoherencies\ncoherency/I\ncoherent/IY\ncoherer/M\ncohesion/MS\ncohesive/PY\ncohesiveness/SM\ncoho/MS\ncohoes\ncohort/SM\ncoif/SM\ncoiffed\ncoiffing\ncoiffure/MGSD\ncoil/UGSAD\ncoin/GZSDRM\ncoinage's/A\ncoinage/SM\ncoincide/GSD\ncoincidence/MS\ncoincident/Y\ncoincidental/Y\ncoined/U\ncoiner/M\ncoinsurance/SM\ncointreau\ncoital/Y\ncoitus/SM\ncoke/MGDS\ncol/SD\ncola/SM\ncolander/SM\ncolatitude/MS\ncold/YRPST\ncoldblooded\ncoldish\ncoldness/MS\ncoleslaw/SM\ncoleus/SM\ncolic/SM\ncolicky\ncoliform\ncoliseum/SM\ncolitis/MS\ncoll/G\ncollaborate/VGNXSD\ncollaboration/M\ncollaborative/SY\ncollaborator/SM\ncollage/MGSD\ncollagen/M\ncollapse/SDG\ncollapsibility/M\ncollapsible\ncollar/DMGS\ncollarbone/MS\ncollard/SM\ncollarless\ncollate/SDVNGX\ncollated/U\ncollateral/SYM\ncollation/M\ncollator/MS\ncolleague/SDGM\ncollect/SAGD\ncollected/PY\ncollectedness/M\ncollectible/S\ncollection/AMS\ncollective/SY\ncollectivism/SM\ncollectivist/MS\ncollectivity/MS\ncollectivization/MS\ncollectivize/DSG\ncollector/MS\ncolleen/SM\ncollege/SM\ncollegiality/S\ncollegian/SM\ncollegiate/Y\ncollide/SDG\ncollie/MZSRD\ncollier/M\ncolliery/MS\ncollimate/C\ncollimated/U\ncollimates\ncollimating\ncollimation/M\ncollimator/M\ncollinear\ncollinearity/M\ncollision/SM\ncollisional\ncollocate/XSDGN\ncollocation/M\ncolloid/MS\ncolloidal/Y\ncolloq\ncolloquial/SY\ncolloquialism/MS\ncolloquies\ncolloquium/SM\ncolloquy/M\ncollude/SDG\ncollusion/SM\ncollusive\ncollying\ncologne/MSD\ncolon/SM\ncolonel/MS\ncolonelcy/MS\ncolonial/SPY\ncolonialism/MS\ncolonialist/MS\ncolonist/SM\ncolonization/ACSM\ncolonize/ACSDG\ncolonized/U\ncolonizer/MS\ncolonizes/U\ncolonnade/MSD\ncolony/SM\ncolophon/SM\ncolor/SRDMGZJ\ncolorant/SM\ncoloration/EMS\ncoloratura/SM\ncolorblind/P\ncolorblindness/S\ncolored/USE\ncolorer/M\ncolorfast/P\ncolorfastness/SM\ncolorful/PY\ncolorfulness/MS\ncolorimeter/SM\ncolorimetry\ncoloring/M\ncolorization/S\ncolorize/GSD\ncolorizing/C\ncolorless/PY\ncolorlessness/SM\ncolors/EA\ncolossal/Y\ncolossi\ncolossus/M\ncolostomy/SM\ncolostrum/SM\ncolt/MRS\ncolter/M\ncoltish/PY\ncoltishness/M\ncolumbine/SM\ncolumn/SDM\ncolumnar\ncolumnist/MS\ncolumnize/GSD\ncom/LJRTZG\ncoma/SM\ncomae\ncomaker/SM\ncomatose\ncomb/SGZDRMJ\ncombat/SVGMD\ncombatant/SM\ncombative/PY\ncombativeness/MS\ncombed/U\ncomber/M\ncombination/ASM\ncombinational/A\ncombinator/SM\ncombinatorial/Y\ncombinatoric/S\ncombine/ZGBRSD\ncombined/AU\ncombiner/M\ncombines/A\ncombining/A\ncombo/MS\ncombusted\ncombustibility/SM\ncombustible/SI\ncombustion/MS\ncombustive\ncome/IZSRGJ\ncomeback/SM\ncomedian/SM\ncomedic\ncomedienne/SM\ncomedown/MS\ncomedy/SM\ncomeliness/SM\ncomely/TPR\ncomer/IM\ncomes/M\ncomestible/MS\ncomet/SM\ncometary\ncometh\ncomeuppance/SM\ncomfit's\ncomfit/SE\ncomfort/ESMDG\ncomfortability/S\ncomfortable/U\ncomfortableness/MS\ncomfortably/U\ncomforted/U\ncomforter/MS\ncomforting/YE\ncomfy/RT\ncomic/MS\ncomical/Y\ncomicality/MS\ncomity/SM\ncomm\ncomma/MS\ncommand/SZRDMGL\ncommandant/MS\ncommandeer/SDG\ncommander/M\ncommanding/Y\ncommandment/SM\ncommando/SM\ncommemorate/SDVNGX\ncommemoration/M\ncommemorative/YS\ncommemorator/S\ncommence/ALDSG\ncommencement/AMS\ncommencer/M\ncommend/GSADRB\ncommendably\ncommendation/ASM\ncommendatory/A\ncommender/AM\ncommensurable/I\ncommensurate/IY\ncommensurates\ncommensuration/SM\ncomment's\ncomment/SUGD\ncommentary/MS\ncommentate/GSD\ncommentator/SM\ncommenter/M\ncommerce/MGSD\ncommercial/PYS\ncommercialism/MS\ncommercialization/SM\ncommercialize/GSD\ncommie/SM\ncommingle/GSD\ncommiserate/VGNXSD\ncommiseration/M\ncommissar/MS\ncommissariat/MS\ncommissary/MS\ncommission's/A\ncommission/ASCGD\ncommissioner/SM\ncommit/SA\ncommitment/SM\ncommittable\ncommittal/MA\ncommittals\ncommitted/UA\ncommittee/MS\ncommitteeman/M\ncommitteemen\ncommitteewoman/M\ncommitteewomen\ncommitting/A\ncommode/MS\ncommodes/IE\ncommodious/YIP\ncommodiousness/MI\ncommodity/MS\ncommodore/SM\ncommon/RYUPT\ncommonality/MS\ncommonalty/MS\ncommoner/MS\ncommonness/MSU\ncommonplace/SP\ncommonplaceness/M\ncommons/M\ncommonsense\ncommonweal/SHM\ncommonwealth/M\ncommonwealths\ncommotion/MS\ncommunal/Y\ncommunality/M\ncommune/XSDNG\ncommunicability/MS\ncommunicable/IU\ncommunicably\ncommunicant/MS\ncommunicate/VNGXSD\ncommunication/M\ncommunicational\ncommunicative/PY\ncommunicativeness/M\ncommunicator/SM\ncommunion/M\ncommunique/S\ncommunism/MS\ncommunist/MS\ncommunistic\ncommunitarian/M\ncommunity/MS\ncommunize/SDG\ncommutable/I\ncommutate/XVGNSD\ncommutation/M\ncommutative/Y\ncommutativity\ncommutator/MS\ncommute/BZGRSD\ncommuter/M\ncomp/GSYD\ncompact/TZGSPRDY\ncompaction/M\ncompactness/MS\ncompactor/MS\ncompanion/GBSMD\ncompanionable/P\ncompanionableness/M\ncompanionably\ncompanionship/MS\ncompanionway/MS\ncompany/MSDG\ncomparabilities\ncomparability/IM\ncomparable/P\ncomparableness/M\ncomparably/I\ncomparative/PYS\ncomparativeness/M\ncomparator/SM\ncompare/GRSDB\ncomparer/M\ncomparison/MS\ncompartment/SDMG\ncompartmental\ncompartmentalization/SM\ncompartmentalize/DSG\ncompass/MSDG\ncompassion/MS\ncompassionate/PSDGY\ncompassionateness/M\ncompatibility/IMS\ncompatible/SI\ncompatibleness/M\ncompatibly/I\ncompatriot/SM\ncompeer/DSGM\ncompel/S\ncompellable\ncompelled\ncompelling/YM\ncompendious\ncompendium/MS\ncompensable\ncompensate/XVNGSD\ncompensated/U\ncompensation/M\ncompensator/M\ncompensatory\ncompete/GSD\ncompetence/ISM\ncompetency's\ncompetency/IS\ncompetent/IY\ncompetition/SM\ncompetitive/YP\ncompetitiveness/SM\ncompetitor/MS\ncompilable/U\ncompilation/SAM\ncompile/ASDCG\ncompiler's\ncompiler/CS\ncomplacence/S\ncomplacency/SM\ncomplacent/Y\ncomplain/GZRDS\ncomplainant/MS\ncomplainer/M\ncomplaining/YU\ncomplaint/MS\ncomplaisance/SM\ncomplaisant/Y\ncomplected\ncomplement/ZSMRDG\ncomplementariness/M\ncomplementarity\ncomplementary/SP\ncomplementation/M\ncomplementer/M\ncomplete/BTYVNGPRSDX\ncompleted/U\ncompletely/I\ncompleteness/ISM\ncompleter/M\ncompletion/MI\ncomplex/TGPRSDY\ncomplexion/DMS\ncomplexional\ncomplexity/MS\ncomplexness/M\ncompliance/SM\ncompliant/Y\ncomplicate/SDG\ncomplicated/YP\ncomplicatedness/M\ncomplication/M\ncomplicator/SM\ncomplicit\ncomplicity/MS\ncomplier/M\ncompliment/ZSMRDG\ncomplimentary/U\ncomplimenter/M\ncomply/ZXRSDNG\ncomponent/SM\ncomport/GLSD\ncomportment/SM\ncompose/CGASDE\ncomposed/PY\ncomposedness/M\ncomposer/CM\ncomposers\ncomposite/YSDXNG\ncomposition/CMA\ncompositional/Y\ncompositions/C\ncompositor/MS\ncompost/DMGS\ncomposure/ESM\ncompote/MS\ncompound/RDMBGS\ncompounded/U\ncompounder/M\ncomprehend/DGS\ncomprehending/U\ncomprehensibility/SIM\ncomprehensible/PI\ncomprehensibleness/IM\ncomprehensibly/I\ncomprehension/IMS\ncomprehensive/YPS\ncomprehensiveness/SM\ncompress/SDUGC\ncompressed/Y\ncompressibility/IM\ncompressible/I\ncompression/CSM\ncompressional\ncompressive/Y\ncompressor/MS\ncomprise/GSD\ncompromise/SRDGMZ\ncompromiser/M\ncompromising/UY\ncomptroller/SM\ncompulsion/SM\ncompulsive/PYS\ncompulsiveness/MS\ncompulsivity\ncompulsorily\ncompulsory/S\ncompunction/MS\ncomputability/M\ncomputable/UI\ncomputably\ncomputation/SM\ncomputational/Y\ncompute/RSDZBG\ncomputed/A\ncomputer/M\ncomputerese\ncomputerization/MS\ncomputerize/SDG\ncomputes/A\ncomputing/A\ncomrade/YMS\ncomradely/P\ncomradeship/MS\ncon/SGM\nconcatenate/XSDG\nconcave/YP\nconcaveness/MS\nconceal/BSZGRDL\nconcealed/U\nconcealer/M\nconcealing/Y\nconcealment/MS\nconceded/Y\nconceit/SGDM\nconceited/YP\nconceitedness/SM\nconceivable/IU\nconceivably/I\nconceive/BGRSD\nconceiver/M\nconcentrate/VNGSDX\nconcentration/M\nconcentrator/MS\nconcentrically\nconcept/SVM\nconception/MS\nconceptional\nconceptual/Y\nconceptuality/M\nconceptualization's\nconceptualization/A\nconceptualizations\nconceptualize/DRSG\nconceptualizing/A\nconcern/USGD\nconcerned/YU\nconcert's\nconcert/EDSG\nconcerted/PY\nconcertina/MDGS\nconcertize/GDS\nconcertmaster/MS\nconcerto/SM\nconcession/R\nconcessionaire/SM\nconcessional\nconcessionary\nconch/MDG\nconchs\nconcierge/SM\nconciliar\nconciliate/GNVX\nconciliation/ASM\nconciliator/MS\nconciliatory/A\nconcise/TYRNPX\nconciseness/SM\nconcision/M\nconclave/S\nconclude/RSDG\nconcluder/M\nconclusion/SM\nconclusive/IPY\nconclusiveness/ISM\nconcoct/RDVGS\nconcocter/M\nconcoction/SM\nconcomitant/YS\nconcordance/MS\nconcordant/Y\nconcordat/SM\nconcourse\nconcrete/NGXRSDPYM\nconcreteness/MS\nconcretion/M\nconcubinage/SM\nconcubine/SM\nconcupiscence/SM\nconcupiscent\nconcur/S\nconcurrence/MS\nconcuss/VD\nconcussion/MS\ncondemn/ZSGRDB\ncondemnate/XN\ncondemnation/M\ncondemnatory\ncondemner/M\ncondensate/NMXS\ncondensation/M\ncondense/ZGSD\ncondenser/M\ncondensible\ncondescend\ncondescending/Y\ncondescension/MS\ncondign\ncondiment/SM\ncondition's\ncondition/AGSJD\nconditional/UY\nconditionals\nconditioned/U\nconditioner/MS\nconditioning/M\ncondo/SM\ncondole\ncondolence/MS\ncondom/SM\ncondominium/MS\ncondone/GRSD\ncondoner/M\ncondor/MS\nconduce/VGSD\nconducive/P\nconduciveness/M\nconduct/V\nconductance/SM\nconductibility/SM\nconductible\nconduction/MS\nconductive/Y\nconductivity/MS\nconductor/MS\nconductress/MS\nconduit/MS\nconeflower/M\nconey's\nconfab/MS\nconfabbed\nconfabbing\nconfabulate/XSDGN\nconfabulation/M\nconfect/S\nconfection/RDMGZS\nconfectioner/M\nconfectionery/SM\nconfectionist\nconfederacy/MS\nconfederate/M\nconfer/SB\nconferee/MS\nconference/DSGM\nconferrable\nconferral/SM\nconferred\nconferrer/SM\nconferring\nconfessed/Y\nconfession/MS\nconfessional/SY\nconfessor/SM\nconfetti/M\nconfidant/SM\nconfidante/SM\nconfide/ZGRSD\nconfidence/SM\nconfident/Y\nconfidential/PY\nconfidentiality/MS\nconfidentialness/M\nconfider/M\nconfiding/PY\nconfiguration/ASM\nconfigure/AGSDB\nconfine/L\nconfined/U\nconfinement/MS\nconfiner/M\nconfirm/AGDS\nconfirmation/ASM\nconfirmatory\nconfirmed/YP\nconfirmedness/M\nconfiscate/DSGNX\nconfiscation/M\nconfiscator/MS\nconfiscatory\nconflagration/MS\nconflate/NGSDX\nconflation/M\nconflict/SVGDM\nconflicting/Y\nconfluence/MS\nconform/B\nconformable/U\nconformal\nconformance/SM\nconformational/Y\nconformer/M\nconformism/SM\nconformist/SM\nconformities\nconformity/MUI\nconfound/R\nconfounded/Y\nconfront/Z\nconfrontation/SM\nconfrontational\nconfronter/M\nconfrre/MS\nconfuse/RBZ\nconfused/PY\nconfusedness/M\nconfusing/Y\nconfutation/MS\nconfute/GRSD\nconfuter/M\nconga/MDG\ncongeal/GSDL\ncongealment/MS\ncongenial/U\ncongeniality/UM\nconger/SM\ncongeries/M\ncongest/VGSD\ncongestion/MS\nconglomerate/XDSNGVM\nconglomeration/M\ncongrats\ncongratulate/NGXSD\ncongratulation/M\ncongratulatory\ncongregate/DSXGN\ncongregation/M\ncongregational\ncongregationalism/MS\ncongregationalist/MS\ncongress/MSDG\ncongressional/Y\ncongressman/M\ncongressmen\ncongresspeople\ncongressperson/S\ncongresswoman/M\ncongresswomen\ncongruence/IM\ncongruences\ncongruency/M\ncongruent/YI\ncongruential\ncongruity/MSI\ncongruous/YIP\ncongruousness/IM\nconic/S\nconical/PSY\nconicalness/M\nconics/M\nconifer/MS\nconiferous\nconjectural/Y\nconjecture/GMDRS\nconjecturer/M\nconjoint\nconjugacy\nconjugal/Y\nconjugate/XVNGYSDP\nconjugation/M\nconjunct/DSV\nconjunctiva/MS\nconjunctive/YS\nconjunctivitis/SM\nconjuration/MS\nconjure/RSDZG\nconjurer/M\nconjuring/M\nconk/ZDR\nconker/M\nconman\nconn/GVDR\nconnect/ADGES\nconnected/U\nconnectedly/E\nconnectedness/ME\nconnectible\nconnection/AME\nconnectionless\nconnections/E\nconnective/SYM\nconnectivity/MS\nconnector/MS\nconnexion/MS\nconniption/MS\nconnivance/MS\nconnive/ZGRSD\nconniver/M\nconnoisseur/MS\nconnotative/Y\nconnubial/Y\nconquer/RDSBZG\nconquerable/U\nconquered/AU\nconqueror/MS\nconquers/A\nconquest/ASM\nconquistador/MS\nconsanguineous/Y\nconsanguinity/SM\nconscienceless\nconscientious/YP\nconscientiousness/MS\nconscionable/U\nconscious/UYSP\nconsciousness/MUS\nconscription/SM\nconsecrate/XDSNGV\nconsecrated/AU\nconsecrates/A\nconsecrating/A\nconsecration/AMS\nconsecutive/YP\nconsecutiveness/M\nconsensus/SM\nconsent/SZGRD\nconsenter/M\nconsenting/Y\nconsequence\nconsequent/PSY\nconsequential/IY\nconsequentiality/S\nconsequentialness/M\nconsequently/I\nconservancy/SM\nconservation/SM\nconservationism\nconservationist/SM\nconservatism/SM\nconservative/SYP\nconservativeness/M\nconservator/MS\nconservatory/MS\nconsider/GASD\nconsiderable/I\nconsiderables\nconsiderably/I\nconsiderate/XIPNY\nconsiderateness/MSI\nconsideration/ASMI\nconsidered/U\nconsiderer/M\nconsidering/S\nconsign/ASGD\nconsignee/SM\nconsignment/SM\nconsist/DSG\nconsistence/S\nconsistency/IMS\nconsistent/IY\nconsistory/MS\nconsolable/I\nconsolation's/E\nconsolation/MS\nconsolatory\nconsole/ZBG\nconsoled/U\nconsoler/M\nconsolidate/NGDSX\nconsolidated/AU\nconsolidates/A\nconsolidation/M\nconsolidator/SM\nconsoling/Y\nconsomm/S\nconsonance/IM\nconsonances\nconsonant/MYS\nconsonantal\nconsortia\nconsortium/M\nconspectus/MS\nconspicuous/YIP\nconspicuousness/IMS\nconspiracy/MS\nconspirator/SM\nconspiratorial/Y\nconstable\nconstabulary/MS\nconstance\nconstancy/IMS\nconstant/IY\nconstants\nconstellation/SM\nconsternate/XNGSD\nconsternation/M\nconstipate/XDSNG\nconstipation/M\nconstituency/MS\nconstituent/SYM\nconstitute/NGVXDS\nconstituted/A\nconstitutes/A\nconstituting/A\nconstitution/AMS\nconstitutional/SY\nconstitutionality's\nconstitutionality/US\nconstitutionally/U\nconstitutive/Y\nconstrain\nconstrained/U\nconstrainedly\nconstraint/MS\nconstrict/SDGV\nconstriction/MS\nconstrictor/MS\nconstruable\nconstruct/ASDGV\nconstructibility\nconstructible/A\nconstruction/MAS\nconstructional/Y\nconstructionist/MS\nconstructions/C\nconstructive/YP\nconstructiveness/SM\nconstructor/MS\nconstrue/GSD\nconsul/KMS\nconsular/S\nconsulate/MS\nconsulship/MS\nconsult/RDVGS\nconsultancy/S\nconsultant/MS\nconsultation/SM\nconsultative\nconsulted/A\nconsulter/M\nconsumable/S\nconsume/JZGSDB\nconsumed/Y\nconsumer/M\nconsumerism/MS\nconsumerist/S\nconsuming/Y\nconsummate/DSGVY\nconsummated/U\nconsumption/SM\nconsumptive/YS\ncont\ncont'd\ncontact's/A\ncontact/BGD\ncontacted/A\ncontacts/A\ncontagion/SM\ncontagious/YP\ncontagiousness/MS\ncontain/SLZGBRD\ncontainer/M\ncontainerization/SM\ncontainerize/GSD\ncontainment/SM\ncontaminant/SM\ncontaminate/SDCXNG\ncontaminated/AU\ncontaminates/A\ncontaminating/A\ncontamination/CM\ncontaminative\ncontaminator/MS\ncontd\ncontemn/SGD\ncontemplate/DVNGX\ncontemplation/M\ncontemplative/PSY\ncontemplativeness/M\ncontemporaneity/MS\ncontemporaneous/PY\ncontemporaneousness/M\ncontempt/M\ncontemptible/P\ncontemptibleness/M\ncontemptibly\ncontemptuous/PY\ncontemptuousness/SM\ncontent/EMDLSG\ncontented/YP\ncontentedly/E\ncontentedness/SM\ncontention/MS\ncontentious/PY\ncontentiousness/SM\ncontently\ncontentment's\ncontentment/ES\nconterminous/Y\ncontestable/I\ncontestant/SM\ncontested/U\ncontextualize/GDS\ncontiguity/MS\ncontiguous/YP\ncontiguousness/M\ncontinence/ISM\ncontinent's\ncontinent/IY\ncontinental/SY\ncontinents\ncontingency/SM\ncontingent/SMY\ncontinua\ncontinuable\ncontinual/Y\ncontinuance/ESM\ncontinuant/M\ncontinuation/ESM\ncontinue/ESDG\ncontinuer/M\ncontinuity/SEM\ncontinuous/YE\ncontinuousness/M\ncontinuum/M\ncontort/VGD\ncontortion/MS\ncontortionist/SM\ncontour\ncontra/S\ncontraband/SM\ncontrabass/M\ncontraception/SM\ncontraceptive/S\ncontract/DG\ncontractible\ncontractile\ncontractual/Y\ncontradict/GDS\ncontradiction/MS\ncontradictorily\ncontradictoriness/M\ncontradictory/PS\ncontradistinction/MS\ncontraflow/S\ncontrail/M\ncontraindicate/SDVNGX\ncontraindication/M\ncontralto/SM\ncontrapositive/S\ncontraption/MS\ncontrapuntal/Y\ncontrariety/MS\ncontrarily\ncontrariness/MS\ncontrariwise\ncontrary/PS\ncontrast/SRDVGZ\ncontrasting/Y\ncontrastive/Y\ncontravene/GSRD\ncontravener/M\ncontravention/MS\ncontretemps/M\ncontribute/XVNZRD\ncontribution/M\ncontributive/Y\ncontributor/SM\ncontributorily\ncontributory/S\ncontrite/NXP\ncontriteness/M\ncontrition/M\ncontrivance/SM\ncontrive/ZGRSD\ncontriver/M\ncontrol's\ncontrol/CS\ncontrollability/M\ncontrollable/IU\ncontrollably/U\ncontrolled/CU\ncontroller/SM\ncontrolling/C\ncontroversial/UY\ncontroversialists\ncontroversy/MS\ncontrovert/DGS\ncontrovertible/I\ncontumacious/Y\ncontumacy/MS\ncontumelious\ncontumely/MS\ncontuse/NGXSD\ncontusion/M\nconundrum/SM\nconurbation/MS\nconvalesce/GDS\nconvalescence/SM\nconvalescent/S\nconvect/DSVG\nconvection/MS\nconvectional\nconvector\nconvene/ASDG\nconvener/MS\nconvenience/ISM\nconvenient/IY\nconventicle/SM\nconvention/MA\nconventional/UY\nconventionalism/M\nconventionalist/M\nconventionality/SUM\nconventionalize/GDS\nconventions\nconvergence/MS\nconvergent\nconversant/Y\nconversation/SM\nconversational/Y\nconversationalist/SM\nconversazione/M\nconverse/Y\nconversion/AM\nconversioning\nconvert/GADS\nconverted/U\nconverter/MS\nconvertibility's/I\nconvertibility/SM\nconvertible/PS\nconvertibleness/M\nconvex/Y\nconvexity/MS\nconvey/BDGS\nconveyance/DRSGMZ\nconveyancer/M\nconveyancing/M\nconveyor/MS\nconvict/SVGD\nconviction/MS\nconvince/RSDZG\nconvinced/U\nconvincer/M\nconvincing/PUY\nconvincingness/M\nconvivial/Y\nconviviality/MS\nconvoke/GSD\nconvolute/XDNY\nconvolution/M\nconvolve/C\nconvolved\nconvolves\nconvolving\nconvoy/GMDS\nconvulse/SDXVNG\nconvulsion/M\nconvulsive/YP\nconvulsiveness/M\ncony/SM\ncoo/GSD\ncook/GZDRMJS\ncookbook/SM\ncooked/AU\ncooker/M\ncookery/MS\ncookie/SM\ncooking/M\ncookout/SM\ncooks/A\ncookware/SM\ncooky's\ncool/YDRPJGZTS\ncoolant/SM\ncooled/U\ncooler/M\ncoolheaded\ncoolie/MS\ncoolness/MS\ncoon/MS!\ncoonskin/MS\ncoop/MDRGZS\ncooper/GDM\ncooperage/MS\ncooperate/VNGXSD\ncooperation/M\ncooperative/PSY\ncooperativeness/SM\ncooperator/MS\ncoordinate/XNGVYPDS\ncoordinated/U\ncoordinateness/M\ncoordination/M\ncoordinator/MS\ncoot/MS\ncootie/SM\ncop/SJMDRG\ncopay/S\ncope/S\ncoper/M\ncopied/A\ncopier/M\ncopies/A\ncopilot/SM\ncoping/M\ncopious/YP\ncopiousness/SM\ncoplanar\ncopolymer/MS\ncopora\ncopped\ncopper/MSGD\ncopperhead/MS\ncopperplate/MS\ncoppersmith/M\ncoppersmiths\ncoppery\ncoppice's\ncopping\ncopra/MS\ncoprolite/M\ncoprophagous\ncops/GDS\ncopse/M\ncopter/SM\ncopula/MS\ncopulate/XDSNGV\ncopulation/M\ncopulative/S\ncopy/MZBDSRG\ncopybook/MS\ncopycat/SM\ncopycatted\ncopycatting\ncopyist/SM\ncopyright/MSRDGZ\ncopyrighter/M\ncopywriter/MS\ncoquetry/MS\ncoquette/DSMG\ncoquettish/Y\ncoracle/SM\ncoral/SM\ncoralline\ncorbel/GMDJS\ncord/FSAEM\ncordage/MS\ncorded/AE\ncorder/AM\ncordial/PYS\ncordiality/MS\ncordialness/M\ncordillera/MS\ncording/MA\ncordite/MS\ncordless\ncordon/DMSG\ncordovan/SM\ncorduroy/GDMS\ncore/MZGDRS\ncored/A\ncorer/M\ncorespondent/MS\ncorgi/MS\ncoriander/SM\ncoring/M\ncork/GZDRMS\ncorked/U\ncorker/M\ncorks/U\ncorkscrew/DMGS\ncorm/MS\ncormorant/MS\ncorn/GZDRMS\ncornball/SM\ncornbread/S\ncorncob/SM\ncorncrake/M\ncornea/SM\ncorneal\ncorner/GDM\ncornerstone/MS\ncornet/SM\ncornfield/SM\ncornflake/S\ncornflour/M\ncornflower/SM\ncornice/GSDM\ncornily\ncorniness/S\ncornmeal/S\ncornrow/GDS\ncornstalk/MS\ncornstarch/SM\ncornucopia/MS\ncorny/RPT\ncorolla/MS\ncorollary/SM\ncorona/SM\ncoronal/MS\ncoronary/S\ncoronate/NX\ncoronation/M\ncoroner/MS\ncoronet/DMS\ncoroutine/SM\ncorp/S\ncorpora/MS\ncorporal/SYM\ncorporate/INVXS\ncorporately\ncorporation/MI\ncorporatism/M\ncorporatist\ncorporeal/IY\ncorporeality/MS\ncorporealness/M\ncorps/SM\ncorpse/M\ncorpsman/M\ncorpsmen\ncorpulence/MS\ncorpulent/YP\ncorpulentness/S\ncorpus/M\ncorpuscle/SM\ncorpuscular\ncorr\ncorral/MS\ncorralled\ncorralling\ncorrect/BPSDRYTGV\ncorrectable/U\ncorrected/U\ncorrection/MS\ncorrectional\ncorrective/YPS\ncorrectly/I\ncorrectness/MSI\ncorrector/MS\ncorrelate/SDXVNG\ncorrelated/U\ncorrelation/M\ncorrelative/YS\ncorrespond/DSG\ncorrespondence/MS\ncorrespondent/SM\ncorresponding/Y\ncorridor/SM\ncorrigenda\ncorrigendum/M\ncorrigible/I\ncorroborate/GNVXDS\ncorroborated/U\ncorroboration/M\ncorroborative/Y\ncorroborator/MS\ncorroboratory\ncorrode/SDG\ncorrodible\ncorrosion/SM\ncorrosive/YPS\ncorrosiveness/M\ncorrugate/NGXSD\ncorrugation/M\ncorrupt/DRYPTSGV\ncorrupted/U\ncorrupter/M\ncorruptibility/SMI\ncorruptible/I\ncorruption/IM\ncorruptions\ncorruptive/Y\ncorruptness/MS\ncorsage/MS\ncorsair/SM\ncorset/GMDS\ncortex/M\ncortical/Y\ncortices\ncorticosteroid/SM\ncortisone/SM\ncortge/MS\ncorundum/MS\ncoruscate/XSDGN\ncoruscation/M\ncorvette/MS\ncos/GDS\ncosign/SRDZG\ncosignatory/MS\ncosily\ncosine/MS\ncosiness/MS\ncosmetic/SM\ncosmetically\ncosmetician/MS\ncosmetologist/MS\ncosmetology/MS\ncosmic\ncosmical/Y\ncosmogonist/MS\ncosmogony/SM\ncosmological/Y\ncosmologist/MS\ncosmology/SM\ncosmonaut/MS\ncosmopolitan/SM\ncosmopolitanism/MS\ncosmos/SM\ncosponsor/DSG\ncossack/S\ncosset/GDS\ncost/MYGVJS\ncostar/S\ncostarred\ncostarring\ncostive/PY\ncostiveness/M\ncostless\ncostliness/SM\ncostly/RTP\ncostume/ZMGSRD\ncostumer/M\ncot/SGMD\ncotangent/SM\ncote/MS\ncoterie/MS\ncoterminous/Y\ncotillion/SM\ncottage/ZMGSRD\ncottager/M\ncottar's\ncotted\ncotter/SDM\ncotton/GSDM\ncottonmouth/M\ncottonmouths\ncottonseed/MS\ncottontail/SM\ncottonwood/SM\ncottony\ncotyledon/MS\ncouch/MSDG\ncouching/M\ncougar/MS\ncough/RDG\ncougher/M\ncoughs\ncould've\ncould/T\ncouldn't\ncoulomb/SM\ncoule/MS\ncouncil/SM\ncouncilman/M\ncouncilmen\ncouncilor/MS\ncouncilperson/S\ncouncilwoman/M\ncouncilwomen\ncounsel/GSDM\ncounsellings\ncounselor/MS\ncount/EGARDS\ncountability/E\ncountable/U\ncountably/U\ncountdown/SM\ncounted/U\ncountenance's\ncountenance/EGDS\ncountenancer/M\ncounter's/E\ncounter/GSMD\ncounteract/DSVG\ncounteraction/SM\ncounterargument/SM\ncounterattack/DRMGS\ncounterbalance/MSDG\ncounterclaim/GSDM\ncounterclockwise\ncounterculture/MS\ncountercyclical\ncounterespionage/MS\ncounterexample/S\ncounterfeit/ZSGRD\ncounterfeiter/M\ncounterflow\ncounterfoil/MS\ncounterforce/M\ncounterinsurgency/MS\ncounterintelligence/MS\ncounterintuitive\ncounterman/M\ncountermand/DSG\ncountermeasure/SM\ncountermen\ncounteroffensive/SM\ncounteroffer/SM\ncounterpane/SM\ncounterpart/SM\ncounterpoint/GSDM\ncounterpoise/GMSD\ncounterproductive\ncounterproposal/M\ncounterrevolution/MS\ncounterrevolutionary/MS\ncounters/E\ncountersign/SDG\ncountersignature/MS\ncountersink/SG\ncounterspy/MS\ncounterstrike\ncountersunk\ncountertenor/SM\ncountervail/DSG\ncounterweight/GMDS\ncountess/MS\ncountless/Y\ncountrify/D\ncountry/MS\ncountryman/M\ncountrymen\ncountryside/MS\ncountrywide\ncountrywoman/M\ncountrywomen\ncounty/SM\ncoup's\ncoup/ASDG\ncoupe/MS\ncouple's\ncouple/ACU\ncoupled/CU\ncoupler's\ncoupler/C\ncouplers\ncouples/CU\ncouplet/SM\ncoupling's/C\ncoupling/SM\ncoupon/SM\ncourage/MS\ncourageous/U\ncourageously\ncourageousness/MS\ncourages/E\ncourgette/MS\ncourier/GMDS\ncourse's/AF\ncourse/EGSRDM\ncourser's/E\ncourser/SM\ncourses/FA\ncoursework\ncoursing/M\ncourt/GZMYRDS\ncourteous/PEY\ncourteousness/EM\ncourteousnesses\ncourtesan/MS\ncourtesied\ncourtesy/ESM\ncourtesying\ncourthouse/MS\ncourtier/SM\ncourtliness/MS\ncourtly/RTP\ncourtroom/MS\ncourtship/SM\ncourtyard/SM\ncouscous/MS\ncousin/YMS\ncousinly/U\ncouture/SM\ncouturier/SM\ncovalent/Y\ncovariance/SM\ncovariant/S\ncovariate/SN\ncovary\ncove/DRSMZG\ncoven/SM\ncovenant/SGRDM\ncovenanted/U\ncovenanter/M\ncover/AEGUDS\ncoverable/E\ncoverage/MS\ncoverall/DMS\ncoverer/AME\ncovering/MS\ncoverlet/MS\ncovers/M\ncoversheet\ncovert/YPS\ncovertness/SM\ncovet/SGRD\ncoveter/M\ncoveting/Y\ncovetous/PY\ncovetousness/SM\ncovey/SM\ncovington\ncow/MDRSZG\ncoward/MYS\ncowardice/MS\ncowardliness/MS\ncowardly/P\ncowbell/MS\ncowbird/MS\ncowboy/MS\ncowcatcher/SM\ncowed/Y\ncower/RDGZ\ncowering/Y\ncowgirl/MS\ncowhand/S\ncowherd/SM\ncowhide/MGSD\ncowl/SGMD\ncowlick/MS\ncowling/M\ncowman/M\ncowmen\ncoworker/MS\ncowpoke/MS\ncowpony\ncowpox/MS\ncowpunch/RZ\ncowpuncher/M\ncowrie/SM\ncowshed/SM\ncowslip/MS\ncox/MDSG\ncoxcomb/MS\ncoxswain/GSMD\ncoy/CDSG\ncoyer\ncoyest\ncoyly\ncoyness/MS\ncoyote/SM\ncoypu/SM\ncozen/SGD\ncozenage/MS\ncozily\ncoziness/MS\ncozy/DSRTPG\ncpd\ncpl\ncps\ncrab/MS\ncrabapple\ncrabbed/YP\ncrabbedness/M\ncrabber/MS\ncrabbily\ncrabbiness/S\ncrabbing/M\ncrabby/PRT\ncrabgrass/S\ncrablike\ncrack/ZSBYRDG\ncrackable/U\ncrackdown/MS\ncracker/M\ncrackerjack/S\ncrackle/GJDS\ncrackling/M\ncrackly/RT\ncrackpot/SM\ncrackup/S\ncradle/SRDGM\ncradler/M\ncradling/M\ncraft/MRDSG\ncraftily\ncraftiness/SM\ncraftsman/M\ncraftsmanship/SM\ncraftsmen\ncraftspeople\ncraftspersons\ncraftswoman\ncraftswomen\ncrafty/TRP\ncrag/SM\ncragginess/SM\ncraggy/RTP\ncram/S\ncrammed\ncrammer/M\ncramming\ncramp/MRDGS\ncramper/M\ncrampon/SM\ncranberry/SM\ncrane/DSGM\ncranelike\ncranial\ncranium/MS\ncrank/SGTRDM\ncrankcase/MS\ncrankily\ncrankiness/MS\ncrankshaft/MS\ncranky/TRP\ncranny/DSGM\ncrap/SMDG!\ncrape/SM\ncrapped\ncrappie/M\ncrapping\ncrappy/RST\ncrapshooter/SM\ncrash/SRDGZ\ncrasher/M\ncrashing/Y\ncrass/TYRP\ncrassness/MS\ncrate/DSRGMZ\ncrater/DMG\ncravat/SM\ncravatted\ncravatting\ncrave/DSRGJ\ncraven/SPYDG\ncravenness/SM\ncraver/M\ncraving/M\ncraw/SYM\ncrawdad/S\ncrawfish's\ncrawl/RDSGZ\ncrawler/M\ncrawlspace/S\ncrawlway\ncrawly/TRS\ncrayfish/GSDM\ncrayon/GSDM\ncraze/GMDS\ncrazily\ncraziness/MS\ncrazy/SRTP\ncreak/SDG\ncreakily\ncreakiness/SM\ncreaky/PTR\ncream/SMRDGZ\ncreamer/M\ncreamery/MS\ncreamily\ncreaminess/SM\ncreamy/TRP\ncrease's\ncrease/IDRSG\ncreased/CU\ncreases/C\ncreasing/C\ncreate/XKVNGADS\ncreated/U\ncreation/MAK\ncreationism/MS\ncreationist/MS\ncreative/YP\ncreativeness/SM\ncreativities\ncreativity's\ncreativity/K\ncreator/MS\ncreature/YMS\ncreatureliness/M\ncreaturely/P\ncredence/MS\ncredent\ncredential/SGMD\ncredenza/SM\ncredibility/IMS\ncredible/I\ncredibly/I\ncredit's\ncredit/EGBSD\ncreditability/M\ncreditable/P\ncreditableness/M\ncreditably/E\ncredited/U\ncreditor/MS\ncreditworthiness\ncredo/SM\ncredulity/ISM\ncredulous/IY\ncredulousness/SM\ncreed's\ncreed/C\ncreedal\ncreeds\ncreek/SM\ncreekside\ncreel/SMDG\ncreep/SGZR\ncreeper/M\ncreepily\ncreepiness/SM\ncreepy/PRST\ncremate/XDSNG\ncremation/M\ncrematoria\ncrematorium/MS\ncrematory/S\ncreme/S\ncrenelate/XGNSD\ncrenelation/M\ncreole/SM\ncreosote/MGDS\ncrepe/DSGM\ncrept\ncrescendo/SCM\ncrescendoed\ncrescendoing\ncrescent/MS\ncress/S\ncrest/SGMD\ncrestfallen/PY\ncrestfallenness/M\ncresting/M\ncrestless\ncretaceous\ncretin/MS\ncretinism/MS\ncretinous\ncretonne/SM\ncrevasse/DSMG\ncrevice/SM\ncrew/DMGS\ncrewel/SM\ncrewelwork/SM\ncrewman/M\ncrewmen\ncrib/SM\ncribbage/SM\ncribbed\ncribber/SM\ncribbing/M\ncrick/GDSM\ncricket/SMZRDG\ncricketer/M\ncried/C\ncrier/CM\ncries/C\ncrime/GMDS\ncriminal/SYM\ncriminality/MS\ncriminalization/C\ncriminalize/GC\ncriminologist/SM\ncriminology/MS\ncrimp/RDGS\ncrimper/M\ncrimson/DMSG\ncringe/SRDG\ncringer/M\ncrinkle/DSG\ncrinkly/TRS\ncrinoline/SM\ncripple/GMZDRS\ncrippler/M\ncrippling/Y\ncrises\ncrisis/M\ncrisp/PGTYRDS\ncrisper/M\ncrispiness/SM\ncrispness/MS\ncrispy/RPT\ncriss\ncrisscross/GDS\ncriteria\ncriterion/M\ncritic/MS\ncritical/YP\ncriticality\ncritically/U\ncriticalness/M\ncriticism/MS\ncriticize/GSRDZ\ncriticized/U\ncriticizer/M\ncriticizes/A\ncriticizing/UY\ncriticizingly/S\ncritique/MGSD\ncritter/SM\ncroak/SRDGZ\ncroaker/M\ncroaky/RT\ncrochet/RDSZJG\ncrocheter/M\ncrock/SGRDM\ncrockery/SM\ncrocodile/MS\ncrocus/SM\ncroft/MRGZS\ncrofter/M\ncroissant/MS\ncrone/SM\ncrony/SM\ncrook/SGDM\ncrooked/TPRY\ncrookedness/SM\ncrookneck/MS\ncroon/SRDGZ\ncrooner/M\ncrop/MS\ncropland/MS\ncropped\ncropper/SM\ncropping\ncroquet/MDSG\ncroquette/SM\ncrosier/SM\ncross/ZTYSRDMPBJG\ncrossarm\ncrossbar/SM\ncrossbarred\ncrossbarring\ncrossbeam/MS\ncrossbones\ncrossbow/SM\ncrossbowman/M\ncrossbowmen\ncrossbred/S\ncrossbreed/SG\ncrosscheck/SGD\ncrosscurrent/SM\ncrosscut/SM\ncrosscutting\ncrossed/UA\ncrosses/UA\ncrossfire/SM\ncrosshatch/GDS\ncrossing/M\ncrossness/MS\ncrossover/MS\ncrosspatch/MS\ncrosspiece/SM\ncrosspoint\ncrossproduct/S\ncrossroad/GSM\ncrossroads/M\ncrosstalk/M\ncrosstown\ncrosswalk/MS\ncrossway/M\ncrosswind/SM\ncrosswise\ncrossword/MS\ncrotch/MDS\ncrotchet/MS\ncrotchetiness/M\ncrotchety/P\ncrotchless\ncrouch/DSG\ncroup/SMDG\ncroupier/M\ncroupy/TZR\ncrow/GDMS\ncrowbait\ncrowbar/SM\ncrowbarred\ncrowbarring\ncrowd/MRDSG\ncrowded/P\ncrowdedness/M\ncrowfeet\ncrowfoot/M\ncrown/RDMSJG\ncrowned/U\ncrowner/M\ncrozier's\ncroton/MS\ncrucial/Y\ncrucible/MS\ncrucifiable\ncrucifix/SM\ncrucifixion/MS\ncruciform/S\ncrucify/NGDS\ncrud/STMR\ncrudded\ncrudding\ncruddy/TR\ncrude/YSP\ncrudeness/MS\ncrudity/MS\ncrudits\ncruel/YRTSP\ncruelness/MS\ncruelty/SM\ncruet/MS\ncruft\ncrufty\ncruise/GZSRD\ncruiser/M\ncruller/SM\ncrumb/GSYDM\ncrumble/DSJG\ncrumbliness/MS\ncrumbly/PTRS\ncrumby/RT\ncrumminess/S\ncrummy/SRTP\ncrump\ncrumpet/SM\ncrumple/DSG\ncrunch/DSRGZ\ncrunchiness/MS\ncrunchy/TRP\ncrupper/MS\ncrusade/GDSRMZ\ncrusader/M\ncruse/MS\ncrush/SRDBGZ\ncrushable/U\ncrusher/M\ncrushing/Y\ncrushproof\ncrust/GMDS\ncrustacean/MS\ncrustal\ncrustily\ncrustiness/SM\ncrusty/SRTP\ncrutch/MDSG\ncrux/MS\ncry/JGDRSZ\ncrybaby/MS\ncryogenic/S\ncryogenics/M\ncryostat/M\ncryosurgery/SM\ncrypt's\ncrypt/CS\ncryptanalysis/M\ncryptanalyst/M\ncryptanalytic\ncryptic\ncryptically\ncryptogram/MS\ncryptographer/MS\ncryptographic\ncryptographically\ncryptography/MS\ncryptologic\ncryptological\ncryptologist/M\ncryptology/M\ncrystal/SM\ncrystalline/S\ncrystallite/SM\ncrystallization/AMS\ncrystallize/SRDZG\ncrystallized/UA\ncrystallizes/A\ncrystallizing/A\ncrystallographer/MS\ncrystallographic\ncrystallography/M\ncrche/SM\ncs's\ncs/EA\nct\nctn\nctr\ncu/DG\ncub/MDRSZG\ncubbed\ncubbing\ncubbyhole/MS\ncube/SM\ncuber/M\ncubic/YS\ncubical/Y\ncubicle/SM\ncubism/SM\ncubist/MS\ncubit/MS\ncuboid\ncuckold/GSDM\ncuckoldry/MS\ncuckoo/SGDM\ncucumber/MS\ncud/MS\ncuddle/GSD\ncuddly/TRP\ncudgel/GSJMD\ncue/MS\ncuff/GSDM\ncuisine/MS\nculinary\ncull/DRGS\ncullender's\nculler/M\nculminate/XSDGN\nculmination/M\nculotte/S\nculpa/SM\nculpability/MS\nculpable/I\nculpableness/M\nculpably\nculprit/SM\ncult/MS\ncultism/SM\ncultist/SM\ncultivable\ncultivate/XBSDGN\ncultivated/U\ncultivation/M\ncultivator/SM\ncultural/Y\nculture/SDGM\ncultured/U\nculvert/SM\ncum/S\ncumber/DSG\ncumbersome/YP\ncumbersomeness/MS\ncumbrous\ncumin/MS\ncummerbund/MS\ncumquat's\ncumulate/XVNGSD\ncumulation/M\ncumulative/Y\ncumuli\ncumulonimbi\ncumulonimbus/M\ncumulus/M\ncuneiform/S\ncunnilingus/SM\ncunning/RYSPT\ncunningness/M\ncunt/SM!\ncup/MS\ncupboard/SM\ncupcake/SM\ncupful/SM\ncupid/S\ncupidinously\ncupidity/MS\ncupola/MDGS\ncupped\ncupping/M\ncupric\ncuprous\ncur's\ncur/IBS\ncurability/MS\ncurable/IP\ncurableness/MI\ncurably/I\ncuracy/SM\ncurare/MS\ncurate/VGMSD\ncurative/YS\ncurator/KMS\ncuratorial\ncurb/SJDMG\ncurbing/M\ncurbside\ncurbstone/MS\ncurd/SMDG\ncurdle/SDG\ncure/KBDRSGZ\ncured/U\ncurer/MK\ncurettage/SM\ncurfew/SM\ncurfs\ncuria/M\ncuriae\ncurie/SM\ncurio/SM\ncuriosity/SM\ncurious/TPRY\ncuriousness/SM\ncurium/MS\ncurl/UDSG\ncurler/SM\ncurlew/MS\ncurlicue/MGDS\ncurliness/SM\ncurling/M\ncurly/PRT\ncurlycue's\ncurmudgeon/MYS\ncurrant/SM\ncurred/AFI\ncurrency's\ncurrency/SF\ncurrent/FSY\ncurrently/A\ncurrentness/M\ncurricle/M\ncurricula\ncurricular\ncurriculum/M\ncurrier/M\ncurring/FAI\ncurry/RSDMG\ncurrycomb/DMGS\ncurs/ASDVG\ncurse's\ncurse/A\ncursed/YRPT\ncursedness/M\ncursive/EPYA\ncursiveness/EM\ncursives\ncursor/DMSG\ncursorily\ncursoriness/SM\ncursory/P\ncurt/TYRP\ncurtail/LSGDR\ncurtailer/M\ncurtailment/SM\ncurtain/GSMD\ncurtness/MS\ncurtsey's\ncurtsy/SDMG\ncurvaceous/YP\ncurvaceousness/S\ncurvature/MS\ncurve/DSGM\ncurved's\ncurved/A\ncurvilinear/Y\ncurvilinearity/M\ncurving/M\ncurvy/RT\ncushion/SMDG\ncushy/TR\ncusp/MS\ncuspid/MS\ncuspidor/MS\ncuss's\ncuss/EGDSR\ncussed/YP\ncussedness/M\ncusses/F\ncussing/F\ncustard/MS\ncustodial\ncustodian/SM\ncustodianship/MS\ncustody/MS\ncustom/SMRZ\ncustomarily\ncustomariness/M\ncustomary/PS\ncustomer/M\ncustomhouse/S\ncustomization/SM\ncustomize/ZGBSRD\ncut/MRST\ncutaneous/Y\ncutaway/SM\ncutback/SM\ncute/SPY\ncuteness/MS\ncutesy/RT\ncuticle/SM\ncutlass/MS\ncutler/SM\ncutlery/MS\ncutlet/SM\ncutoff/MS\ncutout/SM\ncutter/SM\ncutthroat/SM\ncutting/MYS\ncuttle/M\ncuttlebone/SM\ncuttlefish/MS\ncutup/MS\ncutworm/MS\ncw\ncwt\ncyan/MS\ncyanate/M\ncyanic\ncyanide/GMSD\ncyanogen/M\ncybernetic/S\ncybernetics/M\ncyberpunk/S\ncyberspace/S\ncyborg/S\ncyclamen/MS\ncycle's\ncycle/ASDG\ncycler\ncycleway/S\ncyclic\ncyclical/SY\ncycling/M\ncyclist/MS\ncyclohexanol\ncycloid/SM\ncycloidal\ncyclometer/MS\ncyclone/SM\ncyclonic\ncyclopean\ncyclopedia/MS\ncyclopes\ncyclops\ncyclotron/MS\ncyder/SM\ncygnet/MS\ncylinder/GMDS\ncylindric\ncylindrical/Y\ncymbal/SM\ncymbalist/MS\ncynic/MS\ncynical/UY\ncynicism/MS\ncynosure/SM\ncypher/MGSD\ncypreses\ncypress/SM\ncyst/MS\ncystic\ncytochemistry/M\ncytochrome/M\ncytologist/MS\ncytology/MS\ncytolysis/M\ncytoplasm/SM\ncytoplasmic\ncytosine/MS\ncytotoxic\nczar/SM\nczarevitch/M\nczarina/SM\nczarism/M\nczarist/S\nczarship\nd'Arezzo\nd'Estaing\nd'art\nd'etat\nd'etre\nd'oeuvre\nd's/A\nd/JGVX\ndB/M\ndab/S\ndabbed\ndabber/MS\ndabbing\ndabble/RSDZG\ndabbler/M\ndace/MS\ndacha/SM\ndachshund/SM\ndactyl/MS\ndactylic/S\ndad/SM\ndadaism/S\ndadaist/S\ndaddy/SM\ndado/DMG\ndadoes\ndaemon/SM\ndaemonic\ndaffiness/S\ndaffodil/MS\ndaffy/PTR\ndaft/TYRP\ndaftness/MS\ndagger/DMSG\ndaguerreotype/MGDS\ndahlia/MS\ndailiness/MS\ndaily/PS\ndaintily\ndaintiness/MS\ndainty/TPRS\ndaiquiri/SM\ndairy/MJGS\ndairying/M\ndairyland\ndairymaid/SM\ndairyman/M\ndairymen\ndairywoman/M\ndairywomen\ndais/SM\ndaisy/SM\ndale/SMH\ndaleth/M\ndalliance/SM\ndallier/M\ndally/ZRSDG\ndalmatian/S\ndam/MDS\ndamage/MZGRSD\ndamageable\ndamaged/U\ndamager/M\ndamaging/Y\ndamask/DMGS\ndame/SM\ndammed\ndamming\ndammit/S\ndamn/GSBRD\ndamnably\ndamnation/MS\ndamned/TR\ndamnedest/MS\ndamning/Y\ndamp/SGZTXYRDNP\ndamped/U\ndampen/RDZG\ndampener/M\ndamper/M\ndampness/MS\ndamsel/MS\ndamselfly/MS\ndamson/MS\ndance/SRDJGZ\ndancelike\ndancer/M\ndandelion/MS\ndander/DMGS\ndandify/SDG\ndandily\ndandle/GSD\ndandruff/MS\ndandy/TRSM\ndang/SGZRD\ndanger/DMG\ndangerous/YP\ndangerousness/M\ndangle/ZGRSD\ndangler/M\ndangling/Y\ndanish/S\ndank/TPYR\ndankness/MS\ndanseuse/SM\ndapper/PSTRY\ndapperness/M\ndapple/SDG\ndare/ZGDRSJ\ndaredevil/MS\ndaredevilry/S\ndarer/M\ndaresay\ndaring/PY\ndaringness/M\ndark/GTXYRDNSP\ndarken/RDZG\ndarkener/M\ndarkish\ndarkly/TR\ndarkness/MS\ndarkroom/SM\ndarling/YMSP\ndarlingness/M\ndarn/GRDZS\ndarned/TR\ndarner/M\ndarning/M\ndart/MRDGZS\ndartboard/SM\ndarter/M\ndash/GZSRD\ndashboard/SM\ndasher/M\ndashiki/SM\ndashing/Y\ndastard/MYS\ndastardliness/SM\ndastardly/P\ndata/M\ndatabase/DSMG\ndatafile\ndatagram/MS\ndataset/S\ndate/DRSMZGV\ndated/U\ndatedly\ndatedness\ndateless\ndateline/DSMG\ndater/M\ndative/S\ndatum/MS\ndaub/RDSGZ\ndauber/M\ndaughter/MYS\ndaunt/DSG\ndaunted/U\ndaunting/Y\ndauntless/PY\ndauntlessness/SM\ndauphin/SM\ndavenport/MS\ndavit/SM\ndawdle/ZGRSD\ndawdler/M\ndawn/GSDM\nday/SM\ndaybed/S\ndaybreak/SM\ndaycare/S\ndaydream/RDMSZG\ndaydreamer/M\ndaylight/GSDM\ndaysack\ndaytime/SM\ndaze/DSG\ndazed/PY\ndazzle/ZGJRSD\ndazzler/M\ndazzling/Y\ndb\ndbl\ndeacon/DSMG\ndeaconess/MS\ndead/PTXYRN\ndeadbeat/SM\ndeadbolt/S\ndeaden/RDG\ndeadener/M\ndeadening/MY\ndeadhead/MS\ndeadline/MGDS\ndeadliness/SM\ndeadlock/MGDS\ndeadly/RPT\ndeadness/M\ndeadpan/S\ndeadpanned\ndeadpanner\ndeadpanning\ndeadwood/SM\ndeaf/TXPYRN\ndeafen/JGD\ndeafening/MY\ndeafness/MS\ndeal/RSGZJ\ndealer/M\ndealership/MS\ndealing/M\ndeallocator\ndealt\ndean/DMG\ndeanery/MS\ndeanship/SM\ndear/TYRHPS\ndearness/MS\ndearth/M\ndearths\ndeary/MS\ndeassign\ndeath/MY\ndeathbed/MS\ndeathblow/SM\ndeathless/Y\ndeathlike\ndeathly/TR\ndeaths\ndeathtrap/SM\ndeathward\ndeathwatch/MS\ndeb/MS\ndebacle/SM\ndebar/L\ndebark/G\ndebarkation/SM\ndebarment/SM\ndebarring\ndebaser/M\ndebatable/U\ndebate/BMZ\ndebater/M\ndebauch/GDRS\ndebauched/PY\ndebauchedness/M\ndebauchee/SM\ndebaucher/M\ndebauchery/SM\ndebenture/MS\ndebilitate/NGXSD\ndebilitation/M\ndebility/MS\ndebit/DG\ndebonair/PY\ndebonairness/SM\ndebouch/DSG\ndebrief/GJ\ndebris/M\ndebt/SM\ndebtor/SM\ndebut/MDG\ndecade/MS\ndecadency/S\ndecadent/YS\ndecaf/S\ndecaffeinate/DSG\ndecagon/MS\ndecal/SM\ndecamp/L\ndecampment/MS\ndecapitate/GSD\ndecapitator/SM\ndecathlon/SM\ndecay/GRD\ndecease/M\ndecedent/MS\ndeceit/SM\ndeceitful/PY\ndeceitfulness/SM\ndeceive/ZGRSD\ndeceived/U\ndeceiver/M\ndeceives/U\ndeceiving/U\ndeceivingly\ndecelerate/XNGSD\ndeceleration/M\ndecelerator/SM\ndecency/ISM\ndecennial/SY\ndecent/TIYR\ndeception/SM\ndeceptive/YP\ndeceptiveness/SM\ndecertify/N\ndechlorinate/N\ndecibel/MS\ndecidability/U\ndecidable/U\ndecide/GRSDB\ndecided/PY\ndecidedness/M\ndeciduous/YP\ndeciduousness/M\ndecile/SM\ndeciliter/SM\ndecimal/SYM\ndecimate/XNGDS\ndecimation/M\ndecimeter/MS\ndecipher/BRZG\ndecipherable/IU\ndecipherer/M\ndecision/ISM\ndecisional\ndecisioned\ndecisioning\ndecisive/IPY\ndecisiveness/MSI\ndeck/GRDMSJ\ndeckchair\ndecker/M\ndeckhand/S\ndecking/M\ndeclamation/SM\ndeclamatory\ndeclarable\ndeclaration's/A\ndeclaration/MS\ndeclarative/SY\ndeclarator/MS\ndeclaratory\ndeclare/AGSD\ndeclared/U\ndeclarer/MS\ndeclension/SM\ndeclination/MS\ndecline/ZGRSD\ndecliner/M\ndeclivity/SM\ndeco\ndecolletes\ndecolorising\ndecomposability/M\ndecomposable/IU\ndecompose/B\ndecompress/R\ndecongestant/S\ndeconstruction\ndeconvolution\ndecor/S\ndecorate/NGVDSX\ndecorated/AU\ndecorates/A\ndecorating/A\ndecoration/ASM\ndecorative/YP\ndecorativeness/M\ndecorator/SM\ndecorous/PIY\ndecorousness's/I\ndecorousness/MS\ndecorticate/GNDS\ndecortication/M\ndecorum/MS\ndecoupage/MGSD\ndecouple/G\ndecoy/M\ndecrease\ndecreasing/Y\ndecree/RSM\ndecreeing\ndecrement/DMGS\ndecremental\ndecrepit\ndecrepitude/SM\ndecriminalization/S\ndecriminalize/DS\ndecry/G\ndecrypt/GD\ndecryption\ndecustomised\ndedicate/AGDS\ndedicated/Y\ndedication/MS\ndedicative\ndedicator/MS\ndedicatory\ndeduce/RSDG\ndeducible\ndeduct/VG\ndeductibility/M\ndeductible/S\ndeduction/SM\ndeductive/Y\ndeed's\ndeed/IS\ndeeded\ndeeding\ndeejay/MDSG\ndeem/ADGS\ndeemphasis\ndeep/PTXSYRN\ndeepen/DG\ndeepish\ndeepness/MS\ndeer/SM\ndeerskin/MS\ndeerstalker/SM\ndeerstalking/M\ndef/Z\ndeface/LZ\ndefacement/SM\ndefaecate\ndefalcate/NGXSD\ndefalcation/M\ndefamation/SM\ndefamatory\ndefame/ZR\ndefamer/M\ndefault/ZR\ndefaulter/M\ndefeat/ZGD\ndefeated/U\ndefeater/M\ndefeatism/SM\ndefeatist/SM\ndefecate/DSNGX\ndefecation/M\ndefect/MDSVG\ndefection/SM\ndefective/PYS\ndefectiveness/MS\ndefector/MS\ndefendant/SM\ndefended/U\ndefenestrate/GSD\ndefense/VGSDM\ndefenseless/PY\ndefenselessness/MS\ndefenses/U\ndefensibility/M\ndefensible/I\ndefensibly/I\ndefensive/PSY\ndefensiveness/MS\ndeference/MS\ndeferent/S\ndeferential/Y\ndeferrable\ndeferral/SM\ndeferred\ndeferrer/MS\ndeferring\ndeffer\ndefiance/MS\ndefiant/Y\ndefibrillator/M\ndeficiency/MS\ndeficient/SY\ndeficit/MS\ndefier/M\ndefile/L\ndefilement/MS\ndefinable/UI\ndefinably/I\ndefine/AGDRS\ndefined/U\ndefiner/SM\ndefinite/IPY\ndefiniteness/IMS\ndefinition/ASM\ndefinitional\ndefinitive/SYP\ndefinitiveness/M\ndefis\ndeflate/XNGRSDB\ndeflation/M\ndeflationary\ndeflect/DSGV\ndeflected/U\ndeflection/MS\ndeflector/MS\ndefocus\ndefocussing\ndefog\ndefogger/S\ndefoliant/SM\ndefoliator/SM\ndeform/B\ndeformational\ndeformed/U\ndeformity/SM\ndefraud/ZGDR\ndefrauder/M\ndefrayal/SM\ndefrost/RZ\ndefroster/M\ndeft/TYRP\ndeftness/MS\ndefunct/S\ndefy/RDG\ndefying/Y\ndeg\ndegassing\ndegauss/GD\ndegeneracy/MS\ndegenerate/PY\ndegenerateness/M\ndegrade/B\ndegraded/YP\ndegradedness/M\ndegrading/Y\ndegrease\ndegree/SM\ndegum\ndehumanize\ndehydrator/MS\ndeice/ZR\ndeicer/M\ndeictic\ndeification/M\ndeify/SDXGN\ndeign/DGS\ndeist/SM\ndeistic\ndeity/SM\ndeja\ndeject/DSG\ndejected/PY\ndejectedness/M\ndejection/SM\ndelay/D\ndelayer/G\ndelectable/SP\ndelectableness/M\ndelectably\ndelectation/MS\ndelegable\ndelete/XBRSDNG\ndeleted/U\ndeleterious/PY\ndeleteriousness/M\ndeletion/M\ndelfs\ndelft/MS\ndelftware/S\ndeli/SM\ndeliberate/PVY\ndeliberateness/SM\ndeliberative/PY\ndeliberativeness/M\ndelicacy/IMS\ndelicate/IYP\ndelicateness/IM\ndelicatenesses\ndelicates\ndelicatessen/MS\ndelicious/YSP\ndeliciousness/MS\ndelicti\ndelighted/YP\ndelightedness/M\ndelightful/YP\ndelightfulness/M\ndelineate/SDXVNG\ndelineation/M\ndelinquency/MS\ndelinquent/SYM\ndeliquesce/GSD\ndeliquescent\ndelirious/PY\ndeliriousness/MS\ndelirium/SM\ndeliver/AGSD\ndeliverable/U\ndeliverables\ndeliverance/SM\ndelivered/U\ndeliverer/SM\ndelivery/AM\ndeliverymen/M\ndell/SM\ndelphinium/SM\ndelta/MS\ndeltoid/SM\ndelude/RSDG\ndeluder/M\ndeluding/Y\ndeluge/SDG\ndelusion/SM\ndelusional\ndelusive/PY\ndelusiveness/M\ndeluxe\ndelve/GZSRD\ndelver/M\ndemagnify/N\ndemagogic\ndemagogue/GSDM\ndemagoguery/SM\ndemagogy/MS\ndemand/GSRD\ndemander/M\ndemanding/U\ndemandingly\ndemarcate/SDNGX\ndemarcation/M\ndemean/GDS\ndemeanor/SM\ndemented/YP\ndementedness/M\ndementia/MS\ndemesne/SM\ndemigod/MS\ndemijohn/MS\ndemimondaine/SM\ndemimonde/SM\ndemineralization/SM\ndemise/DMG\ndemit\ndemitasse/MS\ndemitted\ndemitting\ndemo/DMPG\ndemocracy/MS\ndemocrat/SM\ndemocratic/U\ndemocratically/U\ndemocratization/MS\ndemocratize/DRSG\ndemocratizes/U\ndemographer/MS\ndemographic/S\ndemographical/Y\ndemography/MS\ndemolish/GSRD\ndemolisher/M\ndemolition/MS\ndemon/SM\ndemonetization/S\ndemoniac/S\ndemoniacal/Y\ndemonic\ndemonology/M\ndemonstrable/I\ndemonstrableness/M\ndemonstrably/I\ndemonstrate/XDSNGV\ndemonstration/M\ndemonstrative/YUP\ndemonstrativeness/UM\ndemonstrativenesses\ndemonstratives\ndemonstrator/MS\ndemoralization/M\ndemoralizer/M\ndemoralizing/Y\ndemote/DGX\ndemotic/S\ndemount/B\ndemulcent/S\ndemultiplex\ndemur/RTS\ndemure/YP\ndemureness/SM\ndemurral/MS\ndemurred\ndemurrer/MS\ndemurring\ndemythologization/M\ndemythologize/R\nden\ndendrite/MS\ndengue/MS\ndeniable/U\ndenial/SM\ndenier/M\ndenigrate/VNGXSD\ndenigration/M\ndenim/SM\ndenizen/SMDG\ndenned\ndenning\ndenominate/V\ndenominational/Y\ndenote/B\ndenouement/MS\ndenounce/LZRSDG\ndenouncement/SM\ndenouncer/M\ndens/RT\ndense/FR\ndensely\ndenseness/SM\ndensitometer/MS\ndensitometric\ndensitometry/M\ndensity/MS\ndent's\ndent/ISGD\ndental/YS\ndentifrice/SM\ndentin/SM\ndentine's\ndentist/SM\ndentistry/MS\ndentition/MS\ndenture/IMS\ndenuclearize/GSD\ndenudation/SM\ndenude/DG\ndenuder/M\ndenunciate/VNGSDX\ndenunciation/M\ndeny/SRDZG\ndenying/Y\ndeodorant/SM\ndeodorization/SM\ndeodorize/GZSRD\ndeodorizer/M\ndeoxyribonucleic\ndepart/L\ndepartment/MS\ndepartmental/Y\ndepartmentalization/SM\ndepartmentalize/DSG\ndeparture/MS\ndepend/B\ndependability/MS\ndependable/P\ndependableness/M\ndependably\ndependence/ISM\ndependency/MS\ndependent's\ndependent/IYS\ndepict/RDSG\ndepicted/U\ndepicter/M\ndepiction/SM\ndepilatory/S\ndeplete/VGNSDX\ndepletion/M\ndeplorable/P\ndeplorableness/M\ndeplorably\ndeplore/SRDBG\ndeplorer/M\ndeploring/Y\ndeploy/AGDLS\ndeployable\ndeployment/SAM\ndepolarize\ndeponent/S\ndeport/LG\ndeportation/MS\ndeportee/SM\ndeportment/MS\ndepose\ndeposit/ADGS\ndepositary/M\ndeposition/A\ndepositor/SAM\ndepository/MS\ndeprave/GSRD\ndepraved/PY\ndepravedness/M\ndepraver/M\ndepravity/SM\ndeprecate/XSDNG\ndeprecating/Y\ndeprecation/M\ndeprecatory\ndepreciable\ndepreciate/XDSNGV\ndepreciating/Y\ndepreciation/M\ndepreciative/Y\ndepress/V\ndepressant/S\ndepressible\ndepression/MS\ndepressive/YS\ndepressor/MS\ndeprive/GSD\ndepth/M\ndepths\ndeputation/SM\ndepute/SDG\ndeputize/DSG\ndeputy/MS\ndequeue\nderail/L\nderailment/MS\nderange/L\nderangement/MS\nderby/SM\ndereference/Z\nderelict/S\ndereliction/SM\nderide/D\nderiding/Y\nderision/SM\nderisive/PY\nderisiveness/MS\nderisory\nderivable/U\nderivate/XNV\nderivation/M\nderivative/SPYM\nderivativeness/M\nderive/B\nderived/U\ndermal\ndermatitides\ndermatitis/MS\ndermatological\ndermatologist/MS\ndermatology/MS\ndermis/SM\nderogate/XDSNGV\nderogation/M\nderogatorily\nderogatory\nderrick/SMDG\nderringer/SM\nderrire/S\ndervish/SM\ndesalinate/NGSDX\ndesalination/M\ndesalinization/MS\ndesalinize/GSD\ndesalt/G\ndescant/M\ndescend/ZGSDR\ndescendant/SM\ndescended/FU\ndescendent's\ndescender/M\ndescending/F\ndescends/F\ndescent\ndescribable/I\ndescribe/ZB\ndescription/MS\ndescriptive/SYP\ndescriptiveness/MS\ndescriptor/SM\ndescry/SDG\ndesecrate/SRDGNX\ndesecrater/M\ndesecration/M\ndesert/ZGMRDS\ndeserter/M\ndesertification\ndesertion/MS\ndeserve/J\ndeserved/YU\ndeservedness/M\ndeserving/Y\ndesiccant/S\ndesiccate/XNGSD\ndesiccation/M\ndesiccator/SM\ndesiderata\ndesideratum/M\ndesign/ADGS\ndesignable\ndesignate/VNGSDX\ndesignation/M\ndesignational\ndesignator/SM\ndesigned/Y\ndesigner/M\ndesigning/U\ndesirabilia\ndesirability's\ndesirability/US\ndesirable/UPS\ndesirableness's/U\ndesirableness/SM\ndesirably/U\ndesire/BR\ndesired/U\ndesirer/M\ndesirous/PY\ndesirousness/M\ndesist/DSG\ndesk/SM\ndesktop/S\ndesolate/PXDRSYNG\ndesolateness/SM\ndesolater/M\ndesolating/Y\ndesolation/M\ndesorption/M\ndespair/SGDR\ndespairer/M\ndespairing/Y\ndesperado/M\ndesperadoes\ndesperate/YNXP\ndesperateness/SM\ndesperation/M\ndespicable\ndespicably\ndespise/SRDG\ndespiser/M\ndespoil/L\ndespoilment/MS\ndespond\ndespondence/S\ndespondency/MS\ndespondent/Y\ndespotic\ndespotically\ndespotism/SM\ndessert/SM\ndessicate/DN\ndestinate/NX\ndestination/M\ndestine/GSD\ndestiny/MS\ndestitute/NXP\ndestituteness/M\ndestitution/M\ndestroy/BZGDRS\ndestroyer/M\ndestruct/VGSD\ndestructibility/SMI\ndestructible/I\ndestruction/SM\ndestructive/YP\ndestructiveness/MS\ndestructor/M\ndesuetude/MS\ndesultorily\ndesultoriness/M\ndesultory/P\ndetach/LSRDBG\ndetached/YP\ndetachedness/M\ndetacher/M\ndetachment/SM\ndetailed/YP\ndetailedness/M\ndetain/LGRDS\ndetainee/S\ndetainer/M\ndetainment/MS\ndetect/DBSVG\ndetectability/U\ndetectable/U\ndetectably/U\ndetected/U\ndetection/SM\ndetective/MS\ndetector/MS\ndetentes\ndetention/SM\ndeter/SL\ndetergency/M\ndetergent/SM\ndeteriorate/XDSNGV\ndeterioration/M\ndeterment/SM\ndeterminability/M\ndeterminable/IP\ndeterminableness/IM\ndeterminacy/I\ndeterminant/MS\ndeterminate/PYIN\ndeterminateness/IM\ndetermination/IM\ndeterminative/P\ndeterminativeness/M\ndetermine/GASD\ndetermined/U\ndeterminedly\ndeterminedness/M\ndeterminer/SM\ndeterminism's/I\ndeterminism/MS\ndeterministic/I\ndeterministically\ndeterred/U\ndeterrence/SM\ndeterrent/SMY\ndeterring\ndeters/V\ndetersive/S\ndetestable/P\ndetestableness/M\ndetestably\ndetestation/SM\ndethrone/L\ndethronement/SM\ndetonable\ndetonate/XDSNGV\ndetonated/U\ndetonation/M\ndetonator/MS\ndetour/G\ndetox/SDG\ndetoxification/M\ndetoxify/NXGSD\ndetract/GVD\ndetractive/Y\ndetribalize/GSD\ndetriment/SM\ndetrimental/SY\ndetritus/M\ndeuce/SDGM\ndeuced/Y\ndeus\ndeuterium/MS\ndeuteron/M\ndevastate/XVNGSD\ndevastating/Y\ndevastation/M\ndevastator/SM\ndevelop/ALZSGDR\ndeveloped/U\ndeveloper/MA\ndevelopment/ASM\ndevelopmental/Y\ndeviance/MS\ndeviancy/S\ndeviant/YMS\ndeviate/XSDGN\ndeviated/U\ndeviating/U\ndeviation/M\ndevil/SLMDG\ndevilish/PY\ndevilishness/MS\ndevilment/SM\ndevilry/MS\ndeviltry/MS\ndevious/YP\ndeviousness/SM\ndevise/JR\ndeviser/M\ndevoice\ndevolution/MS\ndevolve/GSD\ndevote/XN\ndevoted/Y\ndevotee/MS\ndevotion/M\ndevotional/YS\ndevour/SRDZG\ndevourer/M\ndevout/PRYT\ndevoutness/MS\ndew/MDGS\ndewar\ndewberry/MS\ndewclaw/SM\ndewdrop/MS\ndewiness/MS\ndewlap/MS\ndewy/TPR\ndexes/I\ndexter\ndexterity/MS\ndexterous/PY\ndexterousness/MS\ndextrose/SM\ndhoti/SM\ndhow/MS\ndiabase/M\ndiabetes/M\ndiabetic/S\ndiabolic\ndiabolical/YP\ndiabolicalness/M\ndiabolism/M\ndiachronic/P\ndiacritic/MS\ndiacritical/YS\ndiadem/GMDS\ndiaereses\ndiaeresis/M\ndiagnometer/SM\ndiagnosable/U\ndiagnose/BGDS\ndiagnosed/U\ndiagnosis/M\ndiagnostic/MS\ndiagnostically\ndiagnostician/SM\ndiagnostics/M\ndiagonal/YS\ndiagonalize/GDSB\ndiagram/MS\ndiagrammable\ndiagrammatic\ndiagrammaticality\ndiagrammatically\ndiagrammed\ndiagrammer/SM\ndiagramming\ndial/MRDSGZJ\ndialect/MS\ndialectal/Y\ndialectic/MS\ndialectical/Y\ndialed/A\ndialer/M\ndialing/M\ndialog/MS\ndialogged\ndialogging\ndialogue/DS\ndials/A\ndialysis/M\ndialyzed/U\ndialyzes\ndiam\ndiamagnetic\ndiameter/MS\ndiametric\ndiametrical/Y\ndiamond/GSMD\ndiamondback/SM\ndiapason/MS\ndiaper/SGDM\ndiaphanous/YP\ndiaphanousness/M\ndiaphragm/SM\ndiaphragmatic\ndiarist/SM\ndiarrhea/MS\ndiarrheal\ndiary/MS\ndiaspora\ndiastase/SM\ndiastole/MS\ndiastolic\ndiathermy/SM\ndiathesis/M\ndiatom/SM\ndiatomic\ndiatonic\ndiatribe/MS\ndibble/SDMG\ndibs\ndice/GDRS\ndicer/M\ndicey\ndichloride/M\ndichotomization/M\ndichotomize/DSG\ndichotomous/PY\ndichotomy/SM\ndicier\ndiciest\ndicing/M\ndick/GZXRDMS!\ndickens/M\ndicker/DG\ndickey/SM\ndickier\ndickiest\ndicky's\ndicotyledon/SM\ndicotyledonous\ndicta/M\ndictate/SDNGX\ndictation/M\ndictator/MS\ndictatorial/YP\ndictatorialness/M\ndictatorship/SM\ndiction/MS\ndictionary/SM\ndictum/M\ndid/AU\ndidactic/S\ndidactically\ndidactics/M\ndiddle/ZGRSD\ndiddler/M\ndidn't\ndido/M\ndidoes\ndidst\ndie/DS\ndieing\ndielectric/MS\ndiem\ndiereses\ndieresis/M\ndies's\ndies/U\ndiesel/GMDS\ndiet/RDGZSM\ndietary/S\ndieter/M\ndietetic/S\ndietetics/M\ndiethylaminoethyl\ndiethylstilbestrol/M\ndietitian/MS\ndiffer/SZGRD\ndifference's/I\ndifference/DSGM\ndifferences/I\ndifferent/YI\ndifferentiability\ndifferentiable\ndifferential/SMY\ndifferentiate/XSDNG\ndifferentiated/U\ndifferentiation/M\ndifferentiator/SM\ndifferentness\ndifficile\ndifficult/Y\ndifficulty/SM\ndiffidence/MS\ndiffident/Y\ndiffract/GSD\ndiffraction/SM\ndiffractometer/SM\ndiffuse/PRSDZYVXNG\ndiffuseness/MS\ndiffuser/M\ndiffusible\ndiffusion/M\ndiffusional\ndiffusive/YP\ndiffusiveness/M\ndiffusivity/M\ndig/TS\ndigerati\ndigest/RDVGS\ndigested/IU\ndigester/M\ndigestibility/MS\ndigestible/I\ndigestifs\ndigestion/ISM\ndigestive/YSP\ndigger/MS\ndigging/S\ndigit/SM\ndigital/SY\ndigitalis/M\ndigitalization/MS\ndigitalized\ndigitalizes\ndigitalizing\ndigitization/M\ndigitize/ZGDRS\ndigitizer/M\ndignified/U\ndignify/DSG\ndignitary/SM\ndignity/ISM\ndigram\ndigraph/M\ndigraphs\ndigress/GVDS\ndigression/SM\ndigressive/PY\ndigressiveness/M\ndihedral\ndike/DRSMG\ndiker/M\ndiktat/SM\ndilapidate/XGNSD\ndilapidation/M\ndilatation/SM\ndilate/XVNGSD\ndilated/YP\ndilation/M\ndilator/SM\ndilatoriness/M\ndilatory/P\ndilemma/MS\ndilettante/MS\ndilettantish\ndilettantism/MS\ndiligence/SM\ndiligent/YP\ndiligentness/M\ndilithium\ndill/SGMD\ndilling/R\ndillis\ndilly/SM\ndillydally/GSD\ndilogarithm\ndiluent\ndilute/RSDPXYVNG\ndiluted/U\ndiluteness/M\ndilution/M\ndim/RYPZS\ndime/SM\ndimension/MDGS\ndimensional/Y\ndimensionality/M\ndimensionless\ndimer/M\ndimethyl/M\ndimethylglyoxime\ndiminish/SDGBJ\ndiminished/U\ndiminuendo/SM\ndiminution/SM\ndiminutive/SYP\ndiminutiveness/M\ndimity/MS\ndimmed/U\ndimmer/MS\ndimmest\ndimming\ndimness/SM\ndimorphism/M\ndimple/MGSD\ndimply/RT\ndimwit/MS\ndimwitted\ndin/MDRZGS\ndinar/SM\ndine/S\ndiner/M\ndinette/MS\nding/GD\ndingbat/MS\ndinghy/SM\ndingily\ndinginess/SM\ndingle/MS\ndingo/MS\ndingoes\ndingus/SM\ndingy/PRST\ndinky/RST\ndinned\ndinner/SM\ndinnertime/S\ndinnerware/MS\ndinning\ndinosaur/MS\ndint/SGMD\ndiocesan/S\ndiocese/SM\ndiode/SM\ndiopter/MS\ndiorama/SM\ndioxalate\ndioxide/MS\ndioxin/S\ndip/S\ndiphtheria/SM\ndiphthong/SM\ndiplexers\ndiploid/S\ndiploma/SMDG\ndiplomacy/SM\ndiplomat/MS\ndiplomata\ndiplomatic/S\ndiplomatically\ndiplomatics/M\ndiplomatist/SM\ndipodic\ndipody/M\ndipole/MS\ndipped\ndipper/SM\ndipping/S\ndippy/TR\ndipsomania/SM\ndipsomaniac/MS\ndipstick/MS\ndipterous\ndiptych/M\ndiptychs\ndire/YTRP\ndirect/RDYPTSVG\ndirected/IUA\ndirection/MIS\ndirectional/SY\ndirectionality\ndirections/A\ndirective/SM\ndirectivity/M\ndirectly/I\ndirectness/ISM\ndirector/AMS\ndirectorate/SM\ndirectorial\ndirectorship/SM\ndirectory/SM\ndirectrix/MS\ndirects/IA\ndireful/Y\ndireness/M\ndirge/GSDM\ndirigible/S\ndirk/GDMS\ndirndl/MS\ndirt/MS\ndirtily\ndirtiness/SM\ndirty/GPRSDT\ndis/MB\ndisable/LZGD\ndisablement/MS\ndisabler/M\ndisabuse\ndisadvantaged/P\ndisagreeable/S\ndisallow/D\ndisambiguate/DSGNX\ndisappointed/Y\ndisappointing/Y\ndisarming/Y\ndisarrange/L\ndisastrous/Y\ndisband/L\ndisbandment/SM\ndisbar/L\ndisbarment/MS\ndisbarring\ndisbelieving/Y\ndisbursal/S\ndisburse/GDRSL\ndisbursement/MS\ndisburser/M\ndisc/GDM\ndiscern/SDRGL\ndiscerner/M\ndiscernibility\ndiscernible/I\ndiscernibly\ndiscerning/Y\ndiscernment/MS\ndischarged/U\ndisciple/DSMG\ndiscipleship/SM\ndisciplinarian/SM\ndisciplinary\ndiscipline/IDM\ndisciplined/U\ndiscipliner/M\ndisciplines\ndisciplining\ndisclosed/U\ndisco/MG\ndiscography/MS\ndiscolor/G\ndiscolored/MP\ndiscoloreds/U\ndiscombobulate/SDGNX\ndiscomfit/DG\ndiscomfiture/MS\ndiscommode/DG\ndisconcerting/Y\ndisconnect/R\ndisconnected/P\ndisconnectedness/S\ndisconnecter/M\ndisconsolate/YN\ndiscord/G\ndiscordance/SM\ndiscordant/Y\ndiscorporate/D\ndiscotheque/MS\ndiscount/B\ndiscourage/LGDR\ndiscouragement/MS\ndiscouraging/Y\ndiscover/ADGS\ndiscoverable/I\ndiscovered/U\ndiscoverer/S\ndiscovery/SAM\ndiscreet/TRYP\ndiscreetly/I\ndiscreetness's/I\ndiscreetness/SM\ndiscrepancy/SM\ndiscrepant/Y\ndiscrete/YPNX\ndiscreteness/SM\ndiscretion/IMS\ndiscretionary\ndiscretization\ndiscretized\ndiscriminable\ndiscriminant/MS\ndiscriminate/SDVNGX\ndiscriminated/U\ndiscriminating/YI\ndiscrimination/MI\ndiscriminator/MS\ndiscriminatory\ndiscursiveness/S\ndiscus/SM\ndiscussant/MS\ndiscussed/UA\ndiscusser/M\ndiscussion/SM\ndisdain/MGSD\ndisdainful/YP\ndisdainfulness/M\ndisease/G\ndisembowel/SLGD\ndisembowelment/SM\ndisengage/L\ndisfigure/L\ndisfigurement/MS\ndisfranchise/L\ndisfranchisement/MS\ndisgorge\ndisgrace/R\ndisgracer/M\ndisgruntle/DSLG\ndisgruntlement/MS\ndisguise/R\ndisguised/UY\ndisguiser/M\ndisgust\ndisgusted/Y\ndisgustful/Y\ndisgusting/Y\ndish/GD\ndishabille/SM\ndisharmonious\ndishcloth/M\ndishcloths\ndishevel/LDGS\ndishevelment/MS\ndishonest\ndishonored/U\ndishpan/MS\ndishrag/SM\ndishtowel/SM\ndishwasher/MS\ndishwater/SM\ndisillusion/LGD\ndisillusionment/SM\ndisinfectant/MS\ndisinherit\ndisinterested/P\ndisinterestedness/SM\ndisinvest/L\ndisjoin\ndisjointedness/S\ndisjunct/VS\ndisjunctive/YS\ndisk/D\ndiskette/S\ndislike/G\ndislodge/LG\ndislodgement/M\ndismal/PSTRY\ndismalness/M\ndismantle/L\ndismantlement/SM\ndismay/D\ndismayed/U\ndismaying/Y\ndismember/LG\ndismemberment/MS\ndismiss/RZ\ndismissive/Y\ndisoblige/G\ndisorder/Y\ndisordered/YP\ndisorderedness/M\ndisorderliness/M\ndisorderly/P\ndisorganize\ndisorganized/U\ndisparage/RSDLG\ndisparagement/MS\ndisparager/M\ndisparaging/Y\ndisparate/PSY\ndisparateness/M\ndispatch/Z\ndispel/S\ndispelled\ndispelling\ndispensable/I\ndispensary/MS\ndispensate/NX\ndispensation/M\ndispense/ZGDRSB\ndispenser/M\ndispersal/MS\ndispersant/M\ndisperse/XDRSZLNGV\ndispersed/Y\ndisperser/M\ndispersible\ndispersion/M\ndispersive/PY\ndispersiveness/M\ndispirit/DSG\ndisplace/L\ndisplay/AGDS\ndisplayed/U\ndisplease/G\ndispleased/Y\ndispleasure\ndisport\ndisposable/S\ndisposal/SM\ndispose/IGSD\ndisposition/ISM\ndispositional\ndisproportional\ndisproportionate/N\ndisproportionation/M\ndisprove/B\ndisputable/I\ndisputably/I\ndisputant/SM\ndisputation/SM\ndisputatious/Y\ndispute/ZBGSRD\ndisputed/U\ndisputer/M\ndisquiet/M\ndisquieting/Y\ndisquisition/SM\ndisregardful\ndisrepair/M\ndisreputable/P\ndisreputableness/M\ndisrepute/M\ndisrespect\ndisrupt/GVDRS\ndisrupted/U\ndisrupter/M\ndisruption/MS\ndisruptive/YP\ndisruptor/M\ndissatisfy\ndissect/DG\ndissed\ndissemble/ZGRSD\ndissembler/M\ndisseminate/XGNSD\ndissemination/M\ndissension/SM\ndissent/ZGSDR\ndissenter/M\ndissertation/SM\ndisservice\ndisses\ndissever\ndissidence/SM\ndissident/MS\ndissimilar/S\ndissing\ndissipate/XRSDVNG\ndissipated/U\ndissipatedly\ndissipatedness/M\ndissipater/M\ndissipation/M\ndissociable/I\ndissociate/DSXNGV\ndissociated/U\ndissociation/M\ndissociative/Y\ndissoluble/I\ndissolute/PY\ndissoluteness/SM\ndissolve/ASDG\ndissolved/U\ndissonance/SM\ndissonant/Y\ndissuade/GDRS\ndissuader/M\ndissuasive\ndist\ndistaff/SM\ndistal/Y\ndistance/DSMG\ndistant/YP\ndistantness/M\ndistaste\ndistemper\ndistend\ndistension\ndistention/SM\ndistillate/XNMS\ndistillation/M\ndistillery/MS\ndistinct/IYVP\ndistincter\ndistinctest\ndistinction/MS\ndistinctive/YP\ndistinctiveness/MS\ndistinctness/MSI\ndistinguish/BDRSG\ndistinguishable/I\ndistinguishably/I\ndistinguished/U\ndistinguisher/M\ndistort/BGDR\ndistorted/U\ndistorter/M\ndistortion/MS\ndistract/DG\ndistracted/YP\ndistractedness/M\ndistracting/Y\ndistrait\ndistraught/Y\ndistress\ndistressful\ndistressing/Y\ndistribute/ADXSVNGB\ndistributed/U\ndistributer\ndistribution/AM\ndistributional\ndistributive/SPY\ndistributiveness/M\ndistributivity\ndistributor/SM\ndistributorship/M\ndistrict's\ndistrict/GSAD\ndistrust/G\ndisturb/ZGDRS\ndisturbance/SM\ndisturbed/U\ndisturber/M\ndisturbing/Y\ndisulfide/M\ndisuse/M\ndisyllable/M\nditch/MRSDG\nditcher/M\ndither/RDZSG\nditsy/TR\nditto/DMGS\nditty/SDGM\nditz/S\ndiuresis/M\ndiuretic/S\ndiurnal/SY\ndiv/TZGJDRS\ndiva/MS\ndivalent/S\ndivan/SM\ndive/S\ndived/M\ndiver/M\ndiverge/SDG\ndivergence/SM\ndivergent/Y\ndiverse/XYNP\ndiverseness/MS\ndiversification/M\ndiversifier/M\ndiversify/GSRDNX\ndiversion/M\ndiversionary\ndiversity/SM\ndivert/GSD\ndiverticulitis/SM\ndivertimento/M\ndivest/LDGS\ndivestiture/MS\ndivestment/S\ndividable\ndivide/AGDS\ndivided/U\ndividend/MS\ndivider/MS\ndivination/SM\ndivine/RSDTZYG\ndiviner/M\ndivinity/MS\ndivisibility/IMS\ndivisible/I\ndivision/SM\ndivisional\ndivisive/PY\ndivisiveness/MS\ndivisor/SM\ndivorce/GSDLM\ndivorcement/MS\ndivorce/MS\ndivot/MS\ndivulge/GSD\ndivvy/GSDM\ndixieland\ndizzily\ndizziness/SM\ndizzy/PGRSDT\ndizzying/Y\ndjellaba/S\ndjellabah's\ndo/TZRHGJ\ndoable\ndobbin/MS\ndoc/MS\ndocent/SM\ndocile/Y\ndocility/MS\ndock/GZSRDM\ndocker/M\ndocket/GSMD\ndockland/MS\ndockside/M\ndockworker/S\ndockyard/SM\ndoctor/GSDM\ndoctoral\ndoctorate/SM\ndoctrinaire/S\ndoctrinal/Y\ndoctrine/SM\ndocudrama/S\ndocument/RDMZGS\ndocumentary/MS\ndocumentation/MS\ndocumented/U\ndodder/DGS\ndodecahedra\ndodecahedral\ndodecahedron/M\ndodge/GZSRD\ndodgem/S\ndodger/M\ndodo/SM\ndoe/MS\ndoer/MU\ndoes/AU\ndoeskin/MS\ndoesn't\ndoff/SGD\ndog/SM\ndogcart/SM\ndogcatcher/MS\ndoge/SM\ndogeared\ndogfight/GMS\ndogfish/SM\ndogfought\ndogged/PY\ndoggedness/SM\ndoggerel/SM\ndogging\ndoggone/RSDTG\ndoggy/SRMT\ndoghouse/SM\ndogie/SM\ndogleg/SM\ndoglegged\ndoglegging\ndogma/MS\ndogmatic/S\ndogmatically/U\ndogmatics/M\ndogmatism/SM\ndogmatist/SM\ndogsbody/M\ndogtooth/M\ndogtrot/MS\ndogtrotted\ndogtrotting\ndogwood/SM\ndogy's\ndoh's\ndoily/SM\ndoing/MU\ndoldrum/S\ndoldrums/M\ndole/MGDS\ndoled/F\ndoleful/PY\ndolefuller\ndolefullest\ndolefulness/MS\ndoles/F\ndoling/F\ndoll/MDGS\ndollar/SM\ndollop/GSMD\ndolly/SDMG\ndolmen/MS\ndolomite/SM\ndolomitic\ndolor/SM\ndolorous/Y\ndolphin/SM\ndolt/MS\ndoltish/YP\ndoltishness/SM\ndomain/MS\ndome/DSMG\ndomestic/S\ndomestically\ndomesticate/DSXGN\ndomesticated/U\ndomestication/M\ndomesticity/MS\ndomicile/SDMG\ndomiciliary\ndominance/MS\ndominant/YS\ndominate/VNGXSD\ndomination/M\ndominator/M\ndominatrices\ndominatrix\ndomineer/DSG\ndomineering/YP\ndomineeringness/M\ndominion/MS\ndomino/M\ndominoes\ndon't\ndon/S\ndona/MS\ndonate/XVGNSD\ndonation/M\ndonative/M\ndone/AUF\ndong/GDMS\ndongle/S\ndonkey/MS\ndonned\ndonning\ndonnish/YP\ndonnishness/M\ndonnybrook/MS\ndonor/MS\ndonut/MS\ndonutted\ndonutting\ndoodad/MS\ndoodle/SRDZG\ndoodlebug/MS\ndoodler/M\ndoohickey/MS\ndoom/MDGS\ndoomsday/SM\ndoor/GDMS\ndoorbell/SM\ndoorhandles\ndoorkeep/RZ\ndoorkeeper/M\ndoorknob/SM\ndoorman/M\ndoormat/SM\ndoormen\ndoornail/M\ndoorplate/SM\ndoors/I\ndoorstep/MS\ndoorstepped\ndoorstepping\ndoorstop/MS\ndoorway/MS\ndooryard/SM\ndopa/SM\ndopamine\ndopant/M\ndope/DRSMZG\ndoper/M\ndopey\ndopier\ndopiest\ndopiness/S\ndork/S\ndorky/RT\ndorm/MRZS\ndormancy/MS\ndormant/S\ndormer/M\ndormice\ndormitory/SM\ndormouse/M\ndorsal/YS\ndory/SM\ndos/GDS\ndosage/SM\ndose/M\ndosimeter/MS\ndosimetry/M\ndossier/MS\ndost\ndot/MDRSJZG\ndotage/SM\ndotard/MS\ndote/S\ndoter/M\ndoting/Y\ndotted\ndottiness/M\ndotting\ndotty/PRT\ndouble/GPSRDZ\ndoubled/UA\ndoubleheader/MS\ndoubleness/M\ndoubler/M\ndoubles/M\ndoublespeak/S\ndoublet/MS\ndoublethink/M\ndoubleton/M\ndoubling/A\ndoubloon/MS\ndoubly\ndoubt/AGSDMB\ndoubted/U\ndoubter/SM\ndoubtful/YP\ndoubtfulness/SM\ndoubting/Y\ndoubtless/YP\ndoubtlessness/M\ndouche/GSDM\ndough/M\ndoughs\ndoughty/RT\ndoughy/RT\ndour/TYRP\ndourness/MS\ndouse/SRDG\ndouser/M\ndove/RSM\ndovecote/MS\ndovetail/GSDM\ndovish\ndowager/SM\ndowdily\ndowdiness/MS\ndowdy/TPSR\ndowel/GMDS\ndower/GDMS\ndown/GZSRD\ndownbeat/SM\ndowncast/S\ndowndraft/M\ndowner/M\ndownfall/NMS\ndowngrade/GSD\ndownhearted/PY\ndownheartedness/MS\ndownhill/RS\ndownland\ndownload/DGS\ndownpipes\ndownplay/GDS\ndownpour/MS\ndownrange\ndownright/YP\ndownrightness/M\ndownriver\ndownscale/GSD\ndownside/S\ndownsize/DSG\ndownslope\ndownspout/SM\ndownstage/S\ndownstairs\ndownstate/SR\ndownstream\ndownswing/MS\ndowntime/SM\ndowntown/MRS\ndowntowner/M\ndowntrend/M\ndowntrodden\ndownturn/MS\ndownward/YPS\ndownwardness/M\ndownwind\ndowny/RT\ndowry/SM\ndowse/GZSRD\ndowser/M\ndoxology/MS\ndoyen/SM\ndoyenne/SM\ndoz/XGNDRS\ndoze\ndozen/GHD\ndozenths\ndozer/M\ndozy\ndpt\ndrab/YSP\ndrabbed\ndrabber\ndrabbest\ndrabbing\ndrabness/MS\ndrachma/MS\ndraconian\ndraft/AMDGS\ndraftee/SM\ndrafter/MS\ndraftily\ndraftiness/SM\ndrafting/S\ndraftsman/M\ndraftsmanship/SM\ndraftsmen\ndraftsperson\ndraftswoman\ndraftswomen\ndrafty/PTR\ndrag/MS\ndragged\ndragger/M\ndragging/Y\ndraggy/RT\ndragnet/MS\ndragon/SM\ndragonfly/SM\ndragonhead/M\ndragoon/DMGS\ndrain/SZGRDM\ndrainage/MS\ndrainboard/SM\ndrained/U\ndrainer/M\ndrainpipe/MS\ndrake/SM\ndram/MS\ndrama/SM\ndramatic/S\ndramatical/Y\ndramatically/U\ndramatics/M\ndramatist/MS\ndramatization/MS\ndramatize/SRDZG\ndramatized/U\ndramatizer/M\ndramaturgy/M\ndrammed\ndramming\ndrank\ndrape/SRDGZ\ndraper/M\ndrapery/MS\ndrastic\ndrastically\ndrat/S\ndratted\ndratting\ndraw/ASG\ndrawable\ndrawback/MS\ndrawbridge/SM\ndrawer/SM\ndrawing/SM\ndrawl/RDSG\ndrawler/M\ndrawling/Y\ndrawly\ndrawn/AI\ndrawnly\ndrawnness\ndrawstring/MS\ndray/SMDG\ndread/SRDG\ndreadful/YPS\ndreadfulness/SM\ndreadlocks\ndreadnought/SM\ndream/SMRDZG\ndreamboat/SM\ndreamed/U\ndreamer/M\ndreamily\ndreaminess/SM\ndreaming/Y\ndreamland/SM\ndreamless/PY\ndreamlessness/M\ndreamlike\ndreamworld/S\ndreamy/PTR\ndrear/S\ndrearily\ndreariness/SM\ndreary/TRSP\ndredge/MZGSRD\ndredger/M\ndreg/MS\ndrench/GDRS\ndrencher/M\ndress/ADRSG\ndressage/MS\ndressed/U\ndresser's/A\ndresser/MS\ndresses/U\ndressiness/SM\ndressing/MS\ndressmaker/MS\ndressmaking/SM\ndressy/PTR\ndrew/A\ndrib/SM\ndribble/DRSGZ\ndribbler/M\ndriblet/SM\ndried/U\ndrier/M\ndrift/RDZSG\ndrifter/M\ndrifting/Y\ndriftwood/SM\ndrill/MRDZGS\ndriller/M\ndrilling/M\ndrillmaster/SM\ndrink/BRSZG\ndrinkable/S\ndrinker/M\ndrip/SM\ndripped\ndripping/MS\ndrippy/RT\ndrive/SRBGZJ\ndrivel/GZDRS\ndriveler/M\ndriven/P\ndriver/M\ndriveway/MS\ndrizzle/DSGM\ndrizzling/Y\ndrizzly/TR\ndrogue/MS\ndroll/RDSPTG\ndrollery/SM\ndrollness/MS\ndrolly\ndromedary/MS\ndrone/SRDGM\ndroning/Y\ndrool/GSRD\ndroop/SGD\ndroopiness/MS\ndrooping/Y\ndroopy/PRT\ndrop/SM\ndrophead\ndropkick/S\ndroplet/SM\ndropout/MS\ndropped\ndropper/SM\ndropping/MS\ndropsical\ndropsy/MS\ndrosophila/M\ndross/SM\ndrought/SM\ndrove/SRDGZ\ndrover/M\ndrown/RDSJG\ndrowner/M\ndrowse/SDG\ndrowsily\ndrowsiness/SM\ndrowsy/PTR\ndrub/S\ndrubbed\ndrubber/MS\ndrubbing/SM\ndrudge/MGSRD\ndrudger/M\ndrudgery/SM\ndrudging/Y\ndrug/SM\ndrugged\ndruggie/SRT\ndrugging\ndruggist/SM\ndrugless\ndrugstore/SM\ndruid/MS\ndruidism/MS\ndrum/SM\ndrumbeat/SGM\ndrumhead/M\ndrumlin/MS\ndrummed\ndrummer/SM\ndrumming\ndrumstick/SM\ndrunk/SRNYMT\ndrunkard/SM\ndrunken/YP\ndrunkenness/SM\ndrupe/SM\ndruthers\ndry/GYDRSTZ\ndryad/MS\ndryer/MS\ndryish\ndryness/SM\ndrys\ndrystone\ndrywall/GSD\ndual/YS\ndualism/MS\ndualist/M\ndualistic\nduality/MS\ndub/S\ndubbed\ndubber/S\ndubbin/MS\ndubbing/M\ndubiety/MS\ndubious/YP\ndubiousness/SM\nducal\nducat/SM\nduce's\nduce/CAIKF\nduchess/MS\nduchy/SM\nduck/GSRDM\nduckbill/SM\nducker/M\nduckling/SM\nduckpins\nduckpond\nduckweed/MS\nducky/RSMT\nduct's/A\nduct/KMSF\nducted/CFI\nductile/I\nductility/SM\nducting/F\nductless\nducts/CI\nductwork/M\ndud/GMDS\ndudder\ndude/MS\ndudgeon/SM\ndue/PMS\nduel/MRDGZSJ\nduelist/MS\ndueness/M\nduenna/MS\nduet/MS\nduetted\nduetting\nduff/GZSRDM\nduffel/M\nduffer/M\ndug/S\ndugout/SM\nduh\nduke/DSMG\ndukedom/SM\ndulcet/SY\ndulcify\ndulcimer/MS\ndull/SRDPGT\ndullard/MS\ndullness/MS\ndully\ndulness's\nduly/U\ndumb/PSGTYRD\ndumbbell/MS\ndumbfound/GSDR\ndumbness/MS\ndumbstruck\ndumbwaiter/SM\ndumdum/MS\ndummy/SDMG\ndump/SGZRD\ndumper/UM\ndumpiness/MS\ndumpling/MS\ndumpster/S\ndumpy/PRST\ndun/S\ndunce/MS\ndunderhead/MS\ndune/SM\ndung/SGDM\ndungaree/SM\ndungeon/GSMD\ndunghill/MS\ndunk/GSRD\ndunker/M\ndunned\ndunner\ndunnest\ndunning\ndunno/M\nduo/MS\nduodecimal/S\nduodena\nduodenal\nduodenum/M\nduologue/M\nduopolist\nduopoly/M\ndupe/NGDRSMZ\nduper/M\ndupion/M\nduple\nduplex/MSRDG\nduplexer/M\nduplicability/M\nduplicable\nduplicate/ADSGNX\nduplication/AM\nduplicative\nduplicator/MS\nduplicitous\nduplicity/SM\ndurability/MS\ndurable/PS\ndurableness/M\ndurably\ndurance/SM\nduration/MS\ndurational\nduress/SM\nduring\ndurst\ndurum/MS\ndusk/GDMS\nduskiness/MS\ndusky/RPT\ndust/MRDGZS\ndustbin/MS\ndustcart/M\ndustcover\nduster/M\ndustily\ndustiness/MS\ndusting/M\ndustless\ndustman/M\ndustmen\ndustpan/SM\ndusty/RPT\ndutch/MS\nduteous/Y\ndutiable\ndutiful/UPY\ndutifulness/S\nduty/SM\nduvet/SM\nduxes\ndwarf/MTGSPRD\ndwarfish\ndwarfism/MS\ndweeb/S\ndwell/IGS\ndweller/SM\ndwelling/MS\ndwelt/I\ndwindle/GSD\ndyad/MS\ndyadic\ndybbuk/SM\ndybbukim\ndye/JDRSMZG\ndyed/A\ndyeing/M\ndyer/M\ndyes/A\ndyestuff/SM\ndying/UA\ndyke's\ndynamic/S\ndynamical/Y\ndynamics/M\ndynamism/SM\ndynamite/RSDZMG\ndynamiter/M\ndynamized\ndynamo/MS\ndynastic\ndynasty/MS\ndyne/M\ndysentery/SM\ndysfunction/MS\ndysfunctional\ndyslectic/S\ndyslexia/MS\ndyslexic/S\ndyslexically\ndyspepsia/MS\ndyspeptic/S\ndysprosium/MS\ndystopia/M\ndystrophy/M\ndz\ndbutante/SM\ndcolletage/S\ndcollet\ndmod\ndrailleur/MS\ndshabill's\ndtente\ne'en\ne'er\ne's\ne/FMDS\nea\neach\neager/TSPRYM\neagerness/MS\neagle/SDGM\neaglet/SM\near/GSMDYH\nearache/SM\neardrum/SM\nearful/MS\nearing/M\nearl/MS\nearldom/MS\nearliness/SM\nearlobe/S\nearly/PRST\nearmark/DGSJ\nearmuff/SM\nearn/GRDZTSJ\nearned/U\nearner/M\nearnest/PYS\nearnestness/MS\nearning/M\nearphone/MS\nearpieces\nearplug/MS\nearring/MS\nearshot/MS\nearsplitting\nearth/MDNYG\nearthbound\nearthed/U\nearthenware/MS\nearthiness/SM\nearthliness/M\nearthling/MS\nearthly/TPR\nearthmen\nearthmover/M\nearthmoving\nearthquake/SDGM\nearths/U\nearthshaking\nearthward/S\nearthwork/MS\nearthworm/MS\nearthy/PTR\nearwax/MS\nearwig/MS\nearwigged\nearwigging\nease's/EU\nease/LDRSMG\neased/E\neasel/MS\neasement/MS\neaser/M\neases/UE\neasies\neasily/U\neasiness/MSU\neasing/M\neast/GSMR\neastbound\neaster/Y\neasterly/S\neastern/ZR\neasterner/M\neasternmost\neasting/M\neastward/S\neasy/PUTR\neasygoing/P\neasygoingness/M\neat/SJZGNRB\neatable/U\neatables\neaten/U\neater/M\neatery/MS\neating/M\neave/SM\neavesdrop/S\neavesdropped\neavesdropper/MS\neavesdropping\nebb/DSG\nebony/SM\nebullience/SM\nebullient/Y\nebullition/SM\neccentric/MS\neccentrically\neccentricity/SM\neccl\necclesiastic/MS\necclesiastical/Y\nechelon/SGDM\nechinoderm/SM\necho/DMG\nechoed/A\nechoes/A\nechoic\necholocation/SM\neclectic/S\neclectically\neclecticism/MS\neclipse/MGSD\necliptic/MS\neclogue/MS\necocide/SM\necol\necologic\necological/Y\necologist/MS\necology/MS\necon\neconometric/S\neconometricians\neconometrics/M\neconomic/S\neconomical/YU\neconomics/M\neconomist/MS\neconomization\neconomize/GZSRD\neconomizer/M\neconomizing/U\neconomy/MS\necosystem/MS\necru/SM\necstasy/MS\necstatic/S\necstatically\nectoplasm/M\necumenic/MS\necumenical/Y\necumenicism/SM\necumenicist/MS\necumenics/M\necumenism/SM\necumenist/MS\neczema/MS\ned/ASC\neddy/SDMG\nedelweiss/MS\nedema/SM\nedematous\neden\nedge/DRSMZGJ\nedgeless\nedger/M\nedgewise\nedgily\nedginess/MS\nedging/M\nedgy/TRP\nedibility/MS\nedible/SP\nedibleness/SM\nedict/SM\nedification/M\nedifice/SM\nedifier/M\nedify/ZNXGRSD\nedifying/U\nedit/SADG\neditable\nedited/IU\nedition/SM\neditor/MS\neditorial/YS\neditorialist/M\neditorialize/DRSG\neditorializer/M\neditorship/MS\neds\neduc/DBG\neducability/SM\neducable/S\neducate/XASDGN\neducated/YP\neducation/AM\neducational/Y\neducationalists\neducationists\neducative\neducator/MS\neduce/S\neduction/M\nedutainment/S\neek/S\neel/MS\neelgrass/M\neerie/RT\neerily\neeriness/MS\nefface/SRDLG\neffaceable/I\neffacement/MS\neffacer/M\neffect/SMDGV\neffective/YIP\neffectiveness/ISM\neffectives\neffector/MS\neffectual/IYP\neffectualness/MI\neffectuate/SDGN\neffectuation/M\neffeminacy/MS\neffeminate/SY\neffendi/MS\nefferent/SY\neffervesce/GSD\neffervescence/SM\neffervescent/Y\neffete/YP\neffeteness/SM\nefficacious/IPY\nefficaciousness/MI\nefficacy/IMS\nefficiency/MIS\nefficient/ISY\neffigy/SM\neffloresce\nefflorescence/SM\nefflorescent\neffluence/SM\neffluent/MS\neffluvia\neffluvium/M\nefflux/M\neffluxion\neffort/MS\neffortless/PY\neffortlessness/SM\neffrontery/MS\neffulgence/SM\neffulgent\neffuse/XSDVGN\neffusion/M\neffusive/YP\neffusiveness/MS\negad\negalitarian/I\negalitarianism/MS\negalitarians\negg/GMDRS\neggbeater/SM\neggcup/MS\negger/M\negghead/SDM\neggheaded/P\neggnog/SM\neggplant/MS\neggshell/SM\negis's\neglantine/MS\nego/SM\negocentric/S\negocentrically\negocentricity/SM\negoism/SM\negoist/SM\negoistic\negoistical/Y\negomania/MS\negomaniac/MS\negotism/SM\negotist/MS\negotistic\negotistical/Y\negregious/PY\negregiousness/MS\negress/SDMG\negret/SM\neh\neider/SM\neiderdown/SM\neidetic\neigenfunction/MS\neigenstate/S\neigenvalue/SM\neigenvector/MS\neight/SM\neighteen/MHS\neighteenths\neightfold\neighth/MS\neighths\neightieths\neightpence\neighty/SHM\neinsteinium/MS\neisteddfod/M\neither\nejaculate/SDXNG\nejaculation/M\nejaculatory\neject/VGSD\nejecta\nejection/SM\nejector/SM\neke/DSG\neked/A\nel/AS\nelaborate/SDYPVNGX\nelaborateness/SM\nelaboration/M\nelaborators\neland/SM\nelans\nelapse/SDG\nelastic/S\nelastically/I\nelasticated\nelasticity/SM\nelasticize/GDS\nelastodynamics\nelastomer/M\nelate/SRDXGN\nelated/PY\nelatedness/M\nelater/M\nelation/M\nelbow/GDMS\nelbowroom/SM\nelder/SY\nelderberry/MS\nelderflower\nelderliness/M\nelderly/PS\neldest\nelect/ASGD\nelectable/U\nelected/U\nelection/SAM\nelectioneer/GSD\nelective/SPY\nelectiveness/M\nelector/SM\nelectoral/Y\nelectorate/SM\nelectress/M\nelectric/S\nelectrical/PY\nelectricalness/M\nelectrician/SM\nelectricity/SM\nelectrification/M\nelectrifier/M\nelectrify/ZXGNDRS\nelectro/M\nelectrocardiogram/MS\nelectrocardiograph/M\nelectrocardiographs\nelectrocardiography/MS\nelectrochemical/Y\nelectrocute/GNXSD\nelectrocution/M\nelectrode/SM\nelectrodynamic/YS\nelectrodynamics/M\nelectroencephalogram/SM\nelectroencephalograph/M\nelectroencephalographic\nelectroencephalographs\nelectroencephalography/MS\nelectrologist/MS\nelectroluminescent\nelectrolysis/M\nelectrolyte/SM\nelectrolytic\nelectrolytically\nelectrolyze/SDG\nelectromagnet/SM\nelectromagnetic\nelectromagnetically\nelectromagnetism/SM\nelectromechanical\nelectromechanics\nelectromotive\nelectromyograph\nelectromyographic\nelectromyographically\nelectromyography/M\nelectron/MS\nelectronegative\nelectronic/S\nelectronically\nelectronics/M\nelectrophoresis/M\nelectrophorus/M\nelectroplate/DSG\nelectroscope/MS\nelectroscopic\nelectroshock/GDMS\nelectrostatic/S\nelectrostatics/M\nelectrotherapist/M\nelectrotype/GSDZM\nelectroweak\neleemosynary\nelegance/ISM\nelegant/YI\nelegiac/S\nelegiacal\nelegy/SM\nelem\nelement/MS\nelemental/YS\nelementarily\nelementariness/M\nelementary/P\nelephant/SM\nelephantiases\nelephantiasis/M\nelephantine\nelev/NX\nelevate/XDSNG\nelevated/S\nelevation/M\nelevator/SM\neleven/HM\nelevens/S\nelevenths\nelf/M\nelfin/S\nelfish\nelicit/GSD\nelicitation/MS\nelide/GSD\neligibility/ISM\neligible/SI\neliminate/XSDYVGN\nelimination/M\neliminator/SM\nelision/SM\nelite/MPS\nelitism/SM\nelitist/SM\nelixir/MS\nelk/MS\nell/MS\nellipse/MS\nellipsis/M\nellipsoid/MS\nellipsoidal\nellipsometer/MS\nellipsometry\nelliptic\nelliptical/YS\nellipticity/M\nelm/MRS\nelocution/SM\nelocutionary\nelocutionist/MS\nelodea/S\nelongate/NGXSD\nelongation/M\nelope/SRDLG\nelopement/MS\neloper/M\neloquence/SM\neloquent/IY\nels\nelse/M\nelsewhere\neluate/SM\nelucidate/SDVNGX\nelucidation/M\nelude/GSD\nelusive/YP\nelusiveness/SM\nelute/DGN\nelution/M\nelven\nelver/SM\nelves/M\nelvish\nelysian\nem/M\nemaciate/NGXDS\nemaciation/M\nemacs/M\nemail/SMDG\nemanate/XSDVNG\nemanation/M\nemancipate/DSXGN\nemancipation/M\nemancipator/MS\nemasculate/GNDSX\nemasculation/M\nembalm/ZGRDS\nembalmer/M\nembank/GLDS\nembankment/MS\nembarcadero\nembargo/GMD\nembargoes\nembark/ADESG\nembarkation/EMS\nembarrass/SDLG\nembarrassed/U\nembarrassedly\nembarrassing/Y\nembarrassment/MS\nembassy/MS\nembattle/DSG\nembed/S\nembeddable\nembedded\nembedder\nembedding/MS\nembellish/LGRSD\nembellished/U\nembellisher/M\nembellishment/MS\nember/MS\nembezzle/LZGDRS\nembezzlement/MS\nembezzler/M\nembitter/LGDS\nembitterment/SM\nemblazon/DLGS\nemblazonment/SM\nemblem/GSMD\nemblematic\nembodier/M\nembodiment/ESM\nembody/ESDGA\nembolden/DSG\nembolism/SM\nembosom\nemboss/ZGRSD\nembosser/M\nembouchure/SM\nembower/GSD\nembrace/RSDVG\nembraceable\nembracer/M\nembracing/Y\nembrasure/MS\nembrittle\nembrocation/SM\nembroider/SGZDR\nembroiderer/M\nembroidery/MS\nembroil/SLDG\nembroilment/MS\nembryo/SM\nembryologist/SM\nembryology/MS\nembryonic\nemcee/SDM\nemceeing\nemend/SRDGB\nemendation/MS\nemerald/SM\nemerge/ADSG\nemergence/MAS\nemergency/SM\nemergent/S\nemerita\nemeritae\nemeriti\nemeritus\nemery/MGSD\nemetic/S\nemf/S\nemigrant/MS\nemigrate/SDXNG\nemigration/M\neminence/MS\neminent/Y\nemir/SM\nemirate/SM\nemissary/SM\nemission/AMS\nemissivity/MS\nemit/S\nemittance/M\nemitted\nemitter/SM\nemitting\nemollient/S\nemolument/SM\nemote/SDVGNX\nemotion/M\nemotional/UY\nemotionalism/MS\nemotionality/M\nemotionalize/GDS\nemotionless\nemotive/Y\nempaneled\nempaneling\nempath\nempathetic\nempathetical/Y\nempathic\nempathize/SDG\nempathy/MS\nemperor/MS\nemphases\nemphasis/M\nemphasize/ZGCRSDA\nemphatic/U\nemphatically/U\nemphysema/SM\nemphysematous\nempire/MS\nempiric/SM\nempirical/Y\nempiricism/SM\nempiricist/SM\nemplace/L\nemplacement/MS\nemploy/LAGDS\nemployability/UM\nemployable/US\nemployed/U\nemployee/SM\nemployer/SM\nemployment/UMAS\nemporium/MS\nempower/GLSD\nempowerment/MS\nempress/MS\nemptier/M\nemptily\nemptiness/SM\nempty/GRSDPT\nempyrean/SM\nems/C\nemu/SM\nemulate/SDVGNX\nemulation/M\nemulative/Y\nemulator/MS\nemulsification/M\nemulsifier/M\nemulsify/NZSRDXG\nemulsion/SM\nen/BM\nenable/SRDZG\nenabler/M\nenact/SGALD\nenactment/ASM\nenamel/ZGJMDRS\nenameler/M\nenamelware/SM\nenamor/DSG\nenc\nencamp/LSDG\nencampment/MS\nencapsulate/SDGNX\nencapsulation/M\nencase/GSDL\nencasement/SM\nencephalitic\nencephalitides\nencephalitis/M\nencephalographic\nencephalopathy/M\nenchain/SGD\nenchant/ESLDG\nenchanter/MS\nenchanting/Y\nenchantment/MSE\nenchantress/MS\nenchilada/SM\nencipher/SRDG\nencipherer/M\nencircle/GLDS\nencirclement/SM\nencl\nenclave/MGDS\nenclose/GDS\nenclosed/U\nenclosure/SM\nencode/ZJGSRD\nencoder/M\nencomium/SM\nencompass/GDS\nencore/GSD\nencounter/GSD\nencourage/SRDGL\nencouragement/SM\nencourager/M\nencouraging/Y\nencroach/LGRSD\nencroacher/M\nencroachment/MS\nencrust/DSG\nencrustation/MS\nencrypt/DGS\nencrypted/U\nencryption/SM\nencumber/SEDG\nencumbered/U\nencumbrance/SRM\nencumbrancer/M\nency\nencyclical/SM\nencyclopaedia's\nencyclopedia/SM\nencyclopedic\nencyst/GSLD\nencystment/MS\nend/ZGVMDRSJ\nendanger/DGSL\nendangerment/SM\nendear/GSLD\nendearing/Y\nendearment/MS\nendeavor/GZSMRD\nendeavored/U\nendeavorer/M\nendemic/S\nendemically\nendemicity\nender/M\nendgame/M\nending/M\nendive/SM\nendless/PY\nendlessness/MS\nendmost\nendnote/MS\nendocrine/S\nendocrinologist/SM\nendocrinology/SM\nendogamous\nendogamy/M\nendogenous/Y\nendomorphism/SM\nendorse/DRSZGL\nendorsement/MS\nendorser/M\nendoscope/MS\nendoscopic\nendoscopy/SM\nendosperm/M\nendothelial\nendothermic\nendow/GSDL\nendowment/SM\nendpoint/MS\nendue/SDG\nendungeoned\nendurable/U\nendurably/U\nendurance/SM\nendure/BSDG\nenduring/YP\nenduringness/M\nendways\nenema/SM\nenemy/SM\nenergetic/S\nenergetically\nenergetics/M\nenergize/ZGDRS\nenergized/U\nenergizer/M\nenergy/MS\nenervate/XNGVDS\nenervation/M\nenfeeble/GLDS\nenfeeblement/SM\nenfilade/MGDS\nenfold/SGD\nenforce/LDRSZG\nenforceability/M\nenforceable/U\nenforced/Y\nenforcement/SM\nenforcer/M\nenforcible/U\nenfranchise/ELDRSG\nenfranchisement/EMS\nenfranchiser/M\nengage/ADSGE\nengagement/SEM\nengaging/Y\nengender/DGS\nengine/MGSD\nengineer/GSMDJ\nengineering/MY\nengland/ZR\nengorge/LGDS\nengorgement/MS\nengram/MS\nengrave/ZGDRSJ\nengraver/M\nengraving/M\nengross/GLDRS\nengrossed/Y\nengrosser/M\nengrossing/Y\nengrossment/SM\nengulf/GDSL\nengulfment/SM\nenhance/LZGDRS\nenhanceable\nenhancement/MS\nenhancer/M\nenharmonic\nenigma/MS\nenigmatic\nenigmatically\nenjambement's\nenjambment/MS\nenjoin/GSD\nenjoinder\nenjoy/GBDSL\nenjoyability\nenjoyable/P\nenjoyableness/M\nenjoyably\nenjoyment/SM\nenlarge/LDRSZG\nenlargeable\nenlargement/MS\nenlarger/M\nenlighten/GDSL\nenlightened/U\nenlightening/U\nenlightenment/SM\nenlist/SAGDL\nenlistee/MS\nenlister/M\nenlistment/SAM\nenliven/LDGS\nenlivenment/SM\nenmesh/DSLG\nenmeshment/SM\nenmity/MS\nennoble/LDRSG\nennoblement/SM\nennobler/M\nennui/SM\nenormity/SM\nenormous/YP\nenormousness/MS\nenough\nenoughs\nenplane/DSG\nenqueue/DS\nenquirer/S\nenquiringly\nenrage/SDG\nenrapture/GSD\nenrich/LDSRG\nenricher/M\nenrichment/SM\nenrobed\nenroll/LGSD\nenrollee/SM\nenrollment/SM\nens\nensconce/DSG\nensemble/MS\nenshrine/DSLG\nenshrinement/SM\nenshroud/DGS\nensign/SM\nensilage/DSMG\nenslave/ZGLDSR\nenslavement/MS\nenslaver/M\nensnare/GLDS\nensnarement/SM\nensue/SDG\nensure/SRDZG\nensurer/M\nentail/SDRLG\nentailer/M\nentailment/MS\nentangle/EGDRSL\nentanglement/ESM\nentangler/EM\nentente/MS\nenter/ASDG\nentered/U\nenterer/M\nenteritides\nenteritis/SM\nenterprise/GMSR\nenterpriser/M\nenterprising/Y\nentertain/SGZRDL\nentertainer/M\nentertaining/Y\nentertainment/SM\nenthalpy/SM\nenthrall/GDSL\nenthrallment/SM\nenthrone/GDSL\nenthronement/MS\nenthuse/DSG\nenthusiasm/SM\nenthusiast/MS\nenthusiastic/U\nenthusiastically/U\nentice/SRDJLZG\nenticement/SM\nenticing/Y\nentire/SY\nentirety/SM\nentitle/GLDS\nentitlement/MS\nentity/SM\nentomb/GDSL\nentombment/MS\nentomological\nentomologist/S\nentomology/MS\nentourage/SM\nentr'acte/S\nentrails\nentrain/GSLDR\nentrainer/M\nentrance/MGDSL\nentrancement/MS\nentranceway/M\nentrancing/Y\nentrant/MS\nentrap/SL\nentrapment/SM\nentrapped\nentrapping\nentreat/SGD\nentreating/Y\nentreaty/SM\nentrench/LSDG\nentrenchment/MS\nentrepreneur/MS\nentrepreneurial\nentrepreneurship/M\nentropic\nentropy/MS\nentrust/DSG\nentry/ASM\nentryway/SM\nentre/S\nentwine/DSG\nenumerable\nenumerate/AN\nenumerated/U\nenumerates\nenumerating\nenumeration's/A\nenumeration/SM\nenumerative\nenumerator/SM\nenunciable\nenunciate/XGNSD\nenunciated/U\nenunciation/M\nenureses\nenuresis/M\nenvelop/ZGLSDR\nenvelope/MS\nenveloper/M\nenvelopment/MS\nenvenom/SDG\nenviable/U\nenviableness/M\nenviably\nenvied/U\nenvier/M\nenvious/PY\nenviousness/SM\nenviron/LGSD\nenvironment/MS\nenvironmental/Y\nenvironmentalism/SM\nenvironmentalist/SM\nenvisage/DSG\nenvision/GSD\nenvoy/SM\nenvy/SRDMG\nenvying/Y\nenzymatic\nenzymatically\nenzyme/SM\nenzymology/M\neohippus/M\neolian\neon/SM\nepaulet/SM\nephedrine/MS\nephemera/MS\nephemeral/SY\nephemerids\nephemeris/M\nepic/SM\nepically\nepicenter/SM\nepicure/SM\nepicurean/S\nepicycle/MS\nepicyclic\nepicyclical/Y\nepicycloid/M\nepidemic/MS\nepidemically\nepidemiological/Y\nepidemiologist/MS\nepidemiology/MS\nepidermal\nepidermic\nepidermis/MS\nepidural\nepigenetic\nepiglottis/SM\nepigram/MS\nepigrammatic\nepigraph/RM\nepigrapher/M\nepigraphs\nepigraphy/MS\nepilepsy/SM\nepileptic/S\nepilogue/SDMG\nepinephrine/SM\nepiphany/SM\nepiphenomena\nepiscopacy/MS\nepiscopal/Y\nepiscopalian\nepiscopate/MS\nepisode/SM\nepisodic\nepisodically\nepistemic\nepistemological/Y\nepistemology/M\nepistle/MRS\nepistolary/S\nepistolatory\nepitaph/GMD\nepitaphs\nepitaxial/Y\nepitaxy/M\nepithelial\nepithelium/MS\nepithet/MS\nepitome/MS\nepitomize/SRDZG\nepitomized/U\nepitomizer/M\nepoch/M\nepochal/Y\nepochs\neponymous\nepoxy/GSD\nepsilon/SM\nequability/MS\nequable/P\nequableness/M\nequably\nequal/USDY\nequaling\nequality/ISM\nequalization/MS\nequalize/DRSGJZ\nequalized/U\nequalizer/M\nequalizes/U\nequanimity/MS\nequate/NGXBSD\nequation/M\nequator/SM\nequatorial/S\nequerry/MS\nequestrian/S\nequestrianism/SM\nequestrienne/SM\nequiangular\nequidistant/Y\nequilateral/S\nequilibrate/GNSD\nequilibration/M\nequilibrium/MSE\nequine/S\nequinoctial/S\nequinox/MS\nequip/AS\nequipage/SM\nequipartition/M\nequipment/SM\nequipoise/GMSD\nequipotent\nequipped/AU\nequipping/A\nequiproportional\nequiproportionality\nequiproportionate\nequitable/I\nequitableness/M\nequitably/I\nequitation/SM\nequity/IMS\nequiv\nequivalence/DSMG\nequivalent/SY\nequivocal/UY\nequivocalness/MS\nequivocate/NGSDX\nequivocation/M\nequivocator/SM\nera/MS\neradicable/I\neradicate/SDXVGN\neradication/M\neradicator/SM\neras/SRDBGZ\nerase/N\neraser/M\nerasion/M\nerasure/MS\nerbium/SM\nere\nerect/GPSRDY\nerectile\nerection/SM\nerectness/MS\nerector/SM\nerelong\neremite/MS\nerg/SM\nergo\nergodic\nergodicity/M\nergonomic/U\nergonomically\nergonomics/M\nergophobia\nergosterol/SM\nergot/SM\neris\nermine/MSD\nerode/SDG\nerodible\nerogenous\nerosible\nerosion/SM\nerosional\nerosive/P\nerosiveness/M\nerotic/S\nerotica/M\nerotically\neroticism/MS\nerr/DGS\nerrancy/MS\nerrand/MS\nerrant/YS\nerrantry/M\nerrata/SM\nerratic/S\nerratically\nerratum/MS\nerring/UY\nerroneous/YP\nerroneousness/M\nerror/SM\nersatz/S\nerst\nerstwhile\neruct/DGS\neructation/MS\nerudite/NYX\nerudition/M\nerupt/DSVG\neruption/SM\neruptive/SY\nerysipelas/SM\nerythrocyte/SM\nes\nescadrille/M\nescalate/CDSXGN\nescalation/MC\nescalator/SM\nescallop/SGDM\nescapable/I\nescapade/SM\nescape/LGSRDB\nescapee/MS\nescapement/MS\nescaper/M\nescapism/SM\nescapist/S\nescapology\nescarole/MS\nescarpment/MS\neschatology/M\neschew/SGD\nescort/SGMD\nescritoire/SM\nescrow/DMGS\nescudo/MS\nescutcheon/SM\nesophageal\nesophagi\nesophagus/M\nesoteric\nesoterica\nesoterically\nesp\nespadrille/MS\nespalier/SMDG\nespecial/Y\nespionage/SM\nesplanade/SM\nespousal/MS\nespouse/SRDG\nespouser/M\nespresso/SM\nesprit/SM\nespy/GSD\nesquire/GMSD\nessay/SZMGRD\nessayer/M\nessayist/SM\nessence/MS\nessential/USI\nessentialist/M\nessentially\nessentialness/M\nest/RZ\nestablish/LAEGSD\nestablished/U\nestablisher/M\nestablishment/EMAS\nestate/GSDM\nesteem/EGDS\nester/M\nesthete's\nesthetic's\nesthetically\nesthetics's\nestimable/I\nestimableness/M\nestimate/XDSNGV\nestimating/A\nestimation/M\nestimator/SM\nestoppal\nestrange/DRSLG\nestrangement/SM\nestranger/M\nestrogen/SM\nestrous\nestrus/SM\nestuarine\nestuary/SM\net\neta/SM\netc\netcetera/SM\netch/GZJSRD\netcher/M\netching/M\neternal/PSY\neternalness/SM\neternity/SM\nethane/SM\nethanol/MS\nether/SM\nethereal/PY\netherealness/M\netherized\nethic/MS\nethical/PYS\nethically/U\nethicalness/M\nethicist/S\nethnic/S\nethnically\nethnicity/MS\nethnocentric\nethnocentrism/MS\nethnographers\nethnographic\nethnography/M\nethnological\nethnologist/SM\nethnology/SM\nethnomethodology\nethological\nethologist/MS\nethology/SM\nethos/SM\nethyl/SM\nethylene/MS\netiologic\netiological\netiology/SM\netiquette/SM\netymological/Y\netymologist/SM\netymology/MS\neucalypti\neucalyptus/SM\neuchre/MGSD\neuclidean\neugenic/S\neugenically\neugenicist/SM\neugenics/M\neulogist/MS\neulogistic\neulogize/GRSDZ\neulogized/U\neulogizer/M\neulogy/MS\neunuch/M\neunuchs\neuphemism/MS\neuphemist/M\neuphemistic\neuphemistically\neuphonious/Y\neuphonium/M\neuphony/SM\neuphoria/SM\neuphoric\neuphorically\neureka/S\neuropium/MS\neutectic\neuthanasia/SM\neuthenics/M\nevacuate/DSXNGV\nevacuation/M\nevacuee/MS\nevade/SRDBGZ\nevader/M\nevaluable\nevaluate/ADSGNX\nevaluated/U\nevaluation/MA\nevaluational\nevaluative\nevaluator/MS\nevanescence/MS\nevanescent\nevangelic\nevangelical/YS\nevangelicalism/SM\nevangelism/SM\nevangelist/MS\nevangelistic\nevangelize/GDS\nevaporate/VNGSDX\nevaporation/M\nevaporative/Y\nevaporator/MS\nevasion/SM\nevasive/PY\nevasiveness/SM\neve's/A\neve/RSM\neven/PUYRT\nevened\nevener/M\nevenhanded/YP\nevening/SM\nevenness/MSU\nevens\nevensong/MS\nevent/SGM\neventful/YU\neventfulness/SM\neventide/SM\neventual/Y\neventuality/MS\neventuate/GSD\never/T\neverglade/MS\nevergreen/S\neverlasting/PYS\neverlastingness/M\neverliving\nevermore\nevery\neverybody/M\neveryday/P\neverydayness/M\neveryman\neveryone/MS\neveryplace\neverything\neverywhere\neves/A\nevict/DGS\neviction/SM\nevidence/MGSD\nevident/YS\nevidential/Y\nevil/YRPTS\nevildoer/SM\nevildoing/MS\nevilness/MS\nevince/SDG\neviscerate/GNXDS\nevisceration/M\nevocable\nevocate/NVX\nevocation/M\nevocative/YP\nevocativeness/M\nevoke/SDG\nevolute/NMXS\nevolution/M\nevolutionarily\nevolutionary\nevolutionist/MS\nevolve/SDG\newe/MZRS\newer/M\nex/S\nexacerbate/NGXDS\nexacerbation/M\nexact/TGSPRDY\nexacter/M\nexacting/YP\nexactingness/M\nexaction/SM\nexactitude/ISM\nexactly/I\nexactness/MSI\nexaggerate/DSXNGV\nexaggerated/YP\nexaggeration/M\nexaggerative/Y\nexaggerator/MS\nexalt/ZRDGS\nexaltation/SM\nexalted/Y\nexalter/M\nexam/MNS\nexamen/M\nexamination's\nexamination/AS\nexamine/BGZDRS\nexamined/AU\nexaminees\nexaminer/M\nexamines/A\nexamining/A\nexample/DSGM\nexampled/U\nexasperate/DSXGN\nexasperated/Y\nexasperating/Y\nexasperation/M\nexcavate/NGDSX\nexcavation/M\nexcavator/SM\nexceed/SGDR\nexceeder/M\nexceeding/Y\nexcel/S\nexcelled\nexcellence/SM\nexcellency/MS\nexcellent/Y\nexcelling\nexcelsior/S\nexcept/DSGV\nexception/BMS\nexceptionable/U\nexceptional/YU\nexceptionalness/M\nexcerpt/GMDRS\nexcerpter/M\nexcess/GVDSM\nexcessive/PY\nexcessiveness/M\nexchange/GDRSZ\nexchangeable\nexchanger/M\nexchequer/SM\nexcise/XMSDNGB\nexcision/M\nexcitability/MS\nexcitable/P\nexcitableness/M\nexcitably\nexcitation/SM\nexcitatory\nexcite/RSDLBZG\nexcited/Y\nexcitement/MS\nexciter/M\nexciting/U\nexcitingly\nexciton/M\nexclaim/SZDRG\nexclaimer/M\nexclamation/MS\nexclamatory\nexclude/DRSG\nexcluder/M\nexclusion/SZMR\nexclusionary\nexclusioner/M\nexclusive/SPY\nexclusiveness/SM\nexclusivity/MS\nexcommunicate/XVNGSD\nexcommunication/M\nexcoriate/GNXSD\nexcoriation/M\nexcrement/SM\nexcremental\nexcrescence/MS\nexcrescent\nexcreta\nexcrete/NGDRSX\nexcreter/M\nexcretion/M\nexcretory/S\nexcruciate/NGDS\nexcruciating/Y\nexcruciation/M\nexculpate/XSDGN\nexculpation/M\nexculpatory\nexcursion/MS\nexcursionist/SM\nexcursive/PY\nexcursiveness/SM\nexcursus/MS\nexcusable/IP\nexcusableness/IM\nexcusably/I\nexcuse/BGRSD\nexcused/U\nexcuser/M\nexec/MS\nexecrable/P\nexecrableness/M\nexecrably\nexecrate/DSXNGV\nexecration/M\nexecutable/MS\nexecute/NGVZBXDRS\nexecuter/M\nexecution/ZMR\nexecutional\nexecutioner/M\nexecutive/SM\nexecutor/SM\nexecutrices\nexecutrix/M\nexegeses\nexegesis/M\nexegete/M\nexegetic/S\nexegetical\nexemplar/MS\nexemplariness/M\nexemplary/P\nexemplification/M\nexemplifier/M\nexemplify/ZXNSRDG\nexempt/SDG\nexemption/MS\nexercise/ZDRSGB\nexerciser/M\nexert/SGD\nexertion/MS\nexeunt\nexhalation/SM\nexhale/GSD\nexhaust/VGRDS\nexhausted/Y\nexhauster/M\nexhaustible/I\nexhausting/Y\nexhaustion/SM\nexhaustive/YP\nexhaustiveness/MS\nexhibit/VGSD\nexhibition/ZMRS\nexhibitioner/M\nexhibitionism/MS\nexhibitionist/MS\nexhibitor/SM\nexhilarate/XSDVNG\nexhilarating/Y\nexhilaration/M\nexhort/DRSG\nexhortation/SM\nexhorter/M\nexhumation/SM\nexhume/GRSD\nexhumer/M\nexigence/S\nexigency/SM\nexigent/SY\nexiguity/SM\nexiguous\nexile/SDGM\nexist/SDG\nexistence/MS\nexistent/I\nexistential/Y\nexistentialism/MS\nexistentialist/MS\nexistentialistic\nexistents\nexit/MDSG\nexobiology/MS\nexocrine\nexodus/SM\nexogamous\nexogamy/M\nexogenous/Y\nexonerate/SDVGNX\nexoneration/M\nexorbitance/MS\nexorbitant/Y\nexorcise/SDG\nexorcism/SM\nexorcist/SM\nexorcizer/M\nexoskeleton/MS\nexosphere/SM\nexothermic\nexothermically\nexotic/PS\nexotica\nexotically\nexoticism/SM\nexoticness/M\nexp\nexpand/DRSGZB\nexpandability/M\nexpanded/U\nexpander/M\nexpanse/DSXGNVM\nexpansible\nexpansion/M\nexpansionary\nexpansionism/MS\nexpansionist/MS\nexpansive/YP\nexpansiveness/S\nexpatiate/XSDNG\nexpatiation/M\nexpatriate/SDNGX\nexpatriation/M\nexpect/SBGD\nexpectancy/MS\nexpectant/YS\nexpectation/MS\nexpectational\nexpected/UPY\nexpecting/Y\nexpectorant/S\nexpectorate/NGXDS\nexpectoration/M\nexpedience/IS\nexpediency/IMS\nexpedient/YI\nexpedients\nexpedite/ZDRSNGX\nexpediter/M\nexpedition/M\nexpeditionary\nexpeditious/YP\nexpeditiousness/MS\nexpeditor's\nexpel/S\nexpellable\nexpelled\nexpelling\nexpend/SDRGB\nexpendable/S\nexpended/U\nexpender/M\nexpenditure/SM\nexpense/DSGVM\nexpensive/IYP\nexpensiveness/SMI\nexperience/ISDM\nexperienced/U\nexperiencing\nexperiential/Y\nexperiment/GSMDRZ\nexperimental/Y\nexperimentalism/M\nexperimentalist/SM\nexperimentation/SM\nexperimenter/M\nexpert's\nexpert/PISY\nexperted\nexperting\nexpertise/SM\nexpertize/GD\nexpertness/IM\nexpertnesses\nexpiable/I\nexpiate/XGNDS\nexpiation/M\nexpiatory\nexpiration/MS\nexpire/SDG\nexpired/U\nexpiry/MS\nexplain/ADSG\nexplainable/UI\nexplained/U\nexplainer/SM\nexplanation/MS\nexplanatory\nexpletive/SM\nexplicable/I\nexplicate/VGNSDX\nexplication/M\nexplicative/Y\nexplicit/PSY\nexplicitness/SM\nexplode/DSRGZ\nexploded/U\nexploder/M\nexploit/ZGVSMDRB\nexploitation/MS\nexploitative\nexploited/U\nexploiter/M\nexploration/MS\nexploratory\nexplore/DSRBGZ\nexplored/U\nexplorer/M\nexplosion/MS\nexplosive/YPS\nexplosiveness/SM\nexpo/MS\nexponent/MS\nexponential/SY\nexponentiate/XSDNG\nexponentiation/M\nexport's\nexport/AGSD\nexportability\nexportable\nexportation/SM\nexporter/MS\nexpos/RSDZG\nexpose\nexposed/U\nexposer/M\nexposit/D\nexposition/SM\nexpositor/MS\nexpository\nexpostulate/DSXNG\nexpostulation/M\nexposure/SM\nexpound/ZGSDR\nexpounder/M\nexpress/GVDRSY\nexpressed/U\nexpresser/M\nexpressibility/I\nexpressible/I\nexpressibly/I\nexpression/MS\nexpressionism/SM\nexpressionist/S\nexpressionistic\nexpressionless/YP\nexpressive/IYP\nexpressiveness's/I\nexpressiveness/MS\nexpressway/SM\nexpropriate/XDSGN\nexpropriation/M\nexpropriator/SM\nexpulsion/MS\nexpunge/GDSR\nexpunger/M\nexpurgate/SDGNX\nexpurgated/U\nexpurgation/M\nexquisite/YPS\nexquisiteness/SM\next\nextant\nextemporaneous/YP\nextemporaneousness/MS\nextempore/S\nextemporization/SM\nextemporize/ZGSRD\nextemporizer/M\nextend/SGZDR\nextendability/M\nextended/U\nextendedly\nextendedness/M\nextender/M\nextendibility/M\nextendibles\nextensibility/M\nextensible/I\nextension/SM\nextensional/Y\nextensive/PY\nextensiveness/SM\nextensor/MS\nextent/SM\nextenuate/XSDGN\nextenuation/M\nexterior/MYS\nexterminate/XNGDS\nextermination/M\nexterminator/SM\nextern/M\nexternal/YS\nexternalities\nexternalization/SM\nexternalize/GDS\nextinct/DGVS\nextinction/MS\nextinguish/BZGDRS\nextinguishable/I\nextinguisher/M\nextirpate/XSDVNG\nextirpation/M\nextol/S\nextolled\nextoller/M\nextolling\nextort/DRSGV\nextorter/M\nextortion/ZSRM\nextortionate/Y\nextortioner/M\nextortionist/SM\nextra/S\nextracellular/Y\nextract/GVSBD\nextraction/SM\nextractive/Y\nextractor/SM\nextracurricular/S\nextradite/XNGSDB\nextradition/M\nextragalactic\nextralegal/Y\nextramarital\nextramural\nextraneous/YP\nextraneousness/M\nextraordinarily\nextraordinariness/M\nextraordinary/PS\nextrapolate/XVGNSD\nextrapolation/M\nextrasensory\nextraterrestrial/S\nextraterritorial\nextraterritoriality/MS\nextravagance/MS\nextravagant/Y\nextravaganza/SM\nextravehicular\nextravert's\nextrema\nextremal\nextreme/DSRYTP\nextremeness/MS\nextremism/SM\nextremist/MS\nextremity/SM\nextricable/I\nextricate/XSDNG\nextrication/M\nextrinsic\nextrinsically\nextroversion/SM\nextrovert/GMDS\nextrude/GDSR\nextruder/M\nextrusion/MS\nextrusive\nexuberance/MS\nexuberant/Y\nexudate/XNM\nexudation/M\nexude/GSD\nexult/DGS\nexultant/Y\nexultation/SM\nexulting/Y\nexurb/MS\nexurban\nexurbanite/SM\nexurbia/MS\neye/GDRSMZ\neyeball/GSMD\neyebrow/MS\neyed/P\neyedropper/MS\neyeful/MS\neyeglass/MS\neyelash/MS\neyeless\neyelet/GSMD\neyelid/SM\neyeliner/MS\neyeopener/MS\neyeopening\neyepiece/SM\neyer/M\neyeshadow\neyesight/MS\neyesore/SM\neyestrain/MS\neyeteeth\neyetooth/M\neyewash/MS\neyewitness/SM\neyrie's\nf's/KA\nf/IRAC\nfa/M\nfable/GMSRD\nfabler/M\nfabric/MS\nfabricate/SDXNG\nfabrication/M\nfabricator/MS\nfabulists\nfabulous/YP\nfabulousness/M\nfacade/GMSD\nface's\nface/AGCSD\nfacecloth\nfacecloths\nfaceless/P\nfaceplate/M\nfacer/CM\nfacet/SGMD\nfacetious/YP\nfacetiousness/MS\nfacial/YS\nfacile/YP\nfacileness/M\nfacilitate/VNGXSD\nfacilitation/M\nfacilitator/SM\nfacilitatory\nfacility/MS\nfacing/MS\nfacsimile/MSD\nfacsimileing\nfact/MS\nfaction/SM\nfactional\nfactionalism/SM\nfactious/PY\nfactiousness/M\nfactitious\nfacto\nfactoid/S\nfactor/SDMJG\nfactorial/MS\nfactoring's\nfactoring/A\nfactorisable\nfactorization/SM\nfactorize/GSD\nfactory/MS\nfactotum/MS\nfactual/PY\nfactuality/M\nfactualness/M\nfaculty/MS\nfad/ZGSMDR\nfaddish\nfaddist/SM\nfade/S\nfaded/U\nfadedly\nfadeout\nfader/M\nfading's\nfading/U\nfaerie/MS\nfaery's\nfag/MS\nfagged\nfagging\nfaggoting's\nfagot/MDSJG\nfagoting/M\nfail/JSGD\nfailing's\nfailing/UY\nfaille/MS\nfailsafe\nfailure/SM\nfain/GTSRD\nfaint/YRDSGPT\nfainter/M\nfainthearted\nfaintness/MS\nfair/TURYP\nfaired\nfairgoer/S\nfairground/MS\nfairing/MS\nfairish\nfairless\nfairness's\nfairness/US\nfairs\nfairway/MS\nfairy/MS\nfairyland/MS\nfairytale\nfaith's\nfaith/U\nfaithed\nfaithful/UYP\nfaithfulness/MSU\nfaithfuls\nfaithing\nfaithless/YP\nfaithlessness/SM\nfaiths\nfajitas\nfake/ZGDRS\nfaker/M\nfakir/SM\nfalafel\nfalcon/ZSRM\nfalconer/M\nfalconry/MS\nfall/SGZMRN\nfallacious/PY\nfallaciousness/M\nfallacy/MS\nfaller/M\nfallibility/MSI\nfallible/I\nfallibleness/MS\nfallibly/I\nfalloff/S\nfallopian\nfallout/MS\nfallow/PSGD\nfallowness/M\nfalse/PTYR\nfalsehood/SM\nfalseness/SM\nfalsetto/SM\nfalsie/MS\nfalsifiability/M\nfalsifiable/U\nfalsification/M\nfalsifier/M\nfalsify/ZRSDNXG\nfalsity/MS\nfalter/RDSGJ\nfalterer/M\nfaltering/UY\nfame/DSMG\nfamed/C\nfames/C\nfamilial\nfamiliar/YPS\nfamiliarity/MUS\nfamiliarization/MS\nfamiliarize/ZGRSD\nfamiliarized/U\nfamiliarizer/M\nfamiliarizing/Y\nfamiliarly/U\nfamiliarness/M\nfamily/MS\nfamine/SM\nfaming/C\nfamish/GSD\nfamous/PY\nfamously/I\nfamousness/M\nfan/SM\nfanatic/SM\nfanatical/YP\nfanaticalness/M\nfanaticism/MS\nfancied\nfancier/SM\nfanciest\nfanciful/YP\nfancifulness/MS\nfancily\nfanciness/SM\nfancy/IS\nfancying\nfancywork/SM\nfandango/SM\nfanfare/SM\nfanfold/M\nfang/DMS\nfangled\nfanlight/SM\nfanned\nfanning\nfanny/SM\nfanout\nfantail/SM\nfantasia/SM\nfantasist/M\nfantasize/SRDG\nfantastic/S\nfantastical/Y\nfantasy/GMSD\nfanzine/S\nfar/GDR\nfarad/SM\nfaraway\nfarce/SDGM\nfarcical/Y\nfare/MS\nfarer/M\nfarewell/DGMS\nfarfetchedness/M\nfarina/MS\nfarinaceous\nfarm/MRDGZSJ\nfarmer/M\nfarmhand/S\nfarmhouse/SM\nfarming/M\nfarmland/SM\nfarmstead/SM\nfarmworker/S\nfarmyard/MS\nfaro/MS\nfarrago/M\nfarragoes\nfarrier/SM\nfarrow/DMGS\nfarseeing\nfarsighted/YP\nfarsightedness/SM\nfart/MDGS!\nfarther\nfarthermost\nfarthest\nfarthing/SM\nfas\nfascia/SM\nfascicle/DSM\nfasciculate/DNX\nfasciculation/M\nfascinate/SDNGX\nfascinating/Y\nfascination/M\nfascism/MS\nfascist/SM\nfascistic\nfashion's\nfashion/ADSG\nfashionable/PS\nfashionableness/M\nfashionably/U\nfashioner/SM\nfast/GTXSPRND\nfastback/MS\nfastball/S\nfasten/AGUDS\nfastener/MS\nfastening/SM\nfastidious/PY\nfastidiousness/MS\nfastness/MS\nfat/PSGMDY\nfatal/SY\nfatalism/MS\nfatalist/MS\nfatalistic\nfatalistically\nfatality/MS\nfatback/SM\nfate/MS\nfateful/YP\nfatefulness/MS\nfathead/SMD\nfatheaded/P\nfather/DYMGS\nfathered/U\nfatherhood/MS\nfatherland/SM\nfatherless\nfatherliness/M\nfatherly/P\nfathom/MDSBG\nfathomable/U\nfathomless\nfatigue/MGSD\nfatigued/U\nfatiguing/Y\nfatness/SM\nfatso/M\nfatted\nfatten/JZGSRD\nfattener/M\nfatter\nfattest/M\nfattiness/SM\nfatting\nfatty/RSPT\nfatuity/MS\nfatuous/YP\nfatuousness/SM\nfatwa/SM\nfaucet/SM\nfault/CGSMD\nfaultfinder/MS\nfaultfinding/MS\nfaultily\nfaultiness/MS\nfaultless/PY\nfaultlessness/SM\nfaulty/RTP\nfaun/MS\nfauna/MS\nfauvism/S\nfavor/ESMRDGZ\nfavorable/UMPS\nfavorableness/MU\nfavorably/U\nfavored's/U\nfavored/YPSM\nfavoredness/M\nfavorer/EM\nfavoring/MYS\nfavorings/U\nfavorite/SMU\nfavoritism/MS\nfavors/A\nfawn/GZRDMS\nfawner/M\nfawning/Y\nfax/GMDS\nfay/MDRGS\nfaze/DSG\nfaence/S\nfealty/MS\nfear/RDMSG\nfearful/YP\nfearfuller\nfearfullest\nfearfulness/MS\nfearless/PY\nfearlessness/MS\nfearsome/PY\nfearsomeness/M\nfeasibility/SM\nfeasible/UI\nfeasibleness/M\nfeasibly/U\nfeast/GSMRD\nfeaster/M\nfeat/MYRGTS\nfeater/C\nfeather/ZMDRGS\nfeatherbed\nfeatherbedding/SM\nfeatherbrain/MD\nfeathered/U\nfeathering/M\nfeatherless\nfeatherlight\nfeathertop\nfeatherweight/SM\nfeathery/TR\nfeats/C\nfeature/MGSD\nfeatureless\nfebrile\nfecal\nfeces\nfeckless/PY\nfecklessness/M\nfecund/I\nfecundability\nfecundate/XSDGN\nfecundation/M\nfecundity/SM\nfed/U\nfederal/YS\nfederalism/SM\nfederalist/MS\nfederalization/MS\nfederalize/GSD\nfederate/FSDXVNG\nfederated/U\nfederation/FM\nfederative/Y\nfedora/SM\nfeds\nfee/MDS\nfeeble/TPR\nfeebleness/SM\nfeebly\nfeed/GRZJS\nfeedback/SM\nfeedbag/MS\nfeeder/M\nfeeding/M\nfeedlot/SM\nfeedstock\nfeedstuffs\nfeeing\nfeel/GZJRS\nfeeler/M\nfeeling/MYP\nfeelingly/U\nfeelingness/M\nfeet/M\nfeign/RDGS\nfeigned/U\nfeigner/M\nfeint/MDSG\nfeisty/RT\nfeldspar/MS\nfelicitate/XGNSD\nfelicitation/M\nfelicitous/IY\nfelicitousness/M\nfelicity/IMS\nfeline/SY\nfell/PSGZTRD\nfella/S\nfellatio/SM\nfelled/A\nfeller/M\nfelling/A\nfellness/M\nfellow/SGDYM\nfellowman\nfellowmen\nfellowship/SM\nfellowshipped\nfellowshipping\nfelon/MS\nfelonious/PY\nfeloniousness/M\nfelony/MS\nfelt/GSD\nfelting/M\nfem/S\nfemale/MPS\nfemaleness/SM\nfeminine/PYS\nfeminineness/M\nfemininity/MS\nfeminism/MS\nfeminist/MS\nfemme/MS\nfemoral\nfemur/MS\nfen/MS\nfence/SRDJGMZ\nfenced/U\nfencepost/M\nfencer/M\nfencing/M\nfend/RDSCZG\nfender/CM\nfenestration/CSM\nfenland/M\nfennel/SM\nfer/FLC\nferal\nferment/FSCM\nfermentation/MS\nfermented\nfermenter\nfermenting\nfermion/MS\nfermium/MS\nfern/MS\nfernery/M\nferny/TR\nferocious/YP\nferociousness/MS\nferocity/MS\nferret/SMRDG\nferreter/M\nferric\nferris\nferrite/M\nferro\nferroelectric\nferromagnet/M\nferromagnetic\nferrous\nferrule/MGSD\nferry/SDMG\nferryboat/MS\nferryman/M\nferrymen\nfertile/YP\nfertileness/M\nfertility/IMS\nfertilization/ASM\nfertilize/SRDZG\nfertilized/U\nfertilizer/M\nfertilizes/A\nferule/SDGM\nfervency/MS\nfervent/Y\nfervid/YP\nfervidness/M\nfervor/MS\nfess's\nfess/KGFSD\nfest/RVZ\nfestal/S\nfester/GD\nfestival/SM\nfestive/PY\nfestiveness/SM\nfestivity/SM\nfestoon/SMDG\nfeta/MS\nfetal\nfetch/RSDGZ\nfetcher/M\nfetching/Y\nfeted\nfetich's\nfetid/YP\nfetidness/SM\nfeting\nfetish/MS\nfetishism/SM\nfetishist/SM\nfetishistic\nfetlock/MS\nfetter's\nfetter/UGSD\nfettle/GSD\nfettling/M\nfettuccine/S\nfetus/SM\nfeud/MDSG\nfeudal/Y\nfeudalism/MS\nfeudalistic\nfeudatory/M\nfever/SDMG\nfeverish/PY\nfeverishness/SM\nfew/PTRS\nfewness/MS\nfey/RT\nfez/M\nfezzes\nff\nfianc/MS\nfiance/S\nfiasco/M\nfiascoes\nfiat/MS\nfib/SZMR\nfibbed\nfibber/MS\nfibbing\nfiber/DM\nfiberboard/MS\nfiberfill/S\nfiberglass/DSMG\nfibril/MS\nfibrillate/XGNDS\nfibrillation/M\nfibrin/MS\nfibroblast/MS\nfibroid/S\nfibroses\nfibrosis/M\nfibrous/YP\nfibrousness/M\nfibula/M\nfibulae\nfibular\nfices\nfiche/SM\nfichu/SM\nfickle/RTP\nfickleness/MS\nficos\nfiction/SM\nfictional/Y\nfictionalization/MS\nfictionalize/DSG\nfictitious/PY\nfictitiousness/M\nfictive/Y\nficus\nfiddle/GMZJRSD\nfiddler/M\nfiddlestick/SM\nfiddly\nfide/F\nfidelity/IMS\nfidget/DSG\nfidgety\nfiducial/Y\nfiduciary/MS\nfie/S\nfief/MS\nfiefdom/S\nfield/ZISMR\nfielded\nfielder/IM\nfielding\nfieldstone/M\nfieldwork/ZMRS\nfieldworker/M\nfiend/MS\nfiendish/YP\nfiendishness/M\nfierce/RPTY\nfierceness/SM\nfierily\nfieriness/MS\nfiery/PTR\nfies/C\nfiesta/MS\nfife/DRSMZG\nfifer/M\nfifteen/HRMS\nfifteenths\nfifth/Y\nfifths\nfiftieths\nfifty/HSM\nfig/MLS\nfigged\nfigging\nfight/ZSJRG\nfightback\nfighter/MIS\nfighting/IS\nfigment/MS\nfigural\nfiguration/FSM\nfigurative/YP\nfigurativeness/M\nfigure's\nfigure/GFESD\nfigurehead/SM\nfigurer/SM\nfigurine/SM\nfiguring/S\nfilament/MS\nfilamentary\nfilamentous\nfilbert/MS\nfilch/SDG\nfile/KDRSGMZ\nfiled/AC\nfilename/SM\nfiler/KMCS\nfiles/AC\nfilet's\nfilial/UY\nfilibuster/MDRSZG\nfilibusterer/M\nfiligree/MSD\nfiligreeing\nfiling/AC\nfilings\nfill/BAJGSD\nfilled/U\nfiller/MS\nfillet/MDSG\nfilleting/M\nfilling/M\nfillip/MDGS\nfilly/SM\nfilm/SGMD\nfilmdom/M\nfilminess/SM\nfilming/M\nfilmmaker/S\nfilmstrip/SM\nfilmy/RTP\nfilter/RDMSZGB\nfiltered/U\nfilterer/M\nfilth/M\nfilthily\nfilthiness/SM\nfilths\nfilthy/TRSDGP\nfiltrate/SDXMNG\nfiltrated/I\nfiltrates/I\nfiltrating/I\nfiltration/IMS\nfin/TGMDRS\nfinagle/RSDZG\nfinagler/M\nfinal/SY\nfinale/MS\nfinalist/MS\nfinality/MS\nfinalization/SM\nfinalize/GSD\nfinance/MGSDJ\nfinanced/A\nfinances/A\nfinancial/Y\nfinancier/DMGS\nfinancing/A\nfinch/MS\nfind/BRJSGZ\nfindable/U\nfinder/M\nfinding/M\nfine's\nfine/FGSCRDA\nfinely\nfineness/MS\nfinery/MAS\nfinespun\nfinesse/SDMG\nfinger/SGRDMJ\nfingerboard/SM\nfingerer/M\nfingering/M\nfingerless\nfingerling/M\nfingernail/MS\nfingerprint/SGDM\nfingertip/MS\nfinial/SM\nfinical\nfinickiness/S\nfinicky/RPT\nfining/M\nfinis/SM\nfinish/JZGRSD\nfinished/UA\nfinisher/M\nfinishes/A\nfinite/ISPY\nfinitely/C\nfiniteness/MIC\nfink/GDMS\nfinned\nfinner\nfinning\nfinny/RT\nfiord's\nfir/ZGJMDRHS\nfire/MS\nfirearm/SM\nfireball/SM\nfireboat/M\nfirebomb/MDSG\nfirebox/MS\nfirebrand/MS\nfirebreak/SM\nfirebrick/SM\nfirebug/SM\nfirecracker/SM\nfired/U\nfiredamp/SM\nfirefight/JRGZS\nfirefly/MS\nfireguard/M\nfirehouse/MS\nfirelight/GZSM\nfireman/M\nfiremen\nfireplace/MS\nfireplug/MS\nfirepower/SM\nfireproof/SGD\nfirer/M\nfiresafe\nfireside/SM\nfirestorm/SM\nfiretrap/SM\nfiretruck/S\nfirewall/S\nfirewater/SM\nfirewood/MS\nfirework/MS\nfiring/M\nfirkin/M\nfirm's\nfirm/ISFDG\nfirmament/MS\nfirmer\nfirmest\nfirmly/I\nfirmness/MS\nfirmware/MS\nfirring\nfirst/SY\nfirstborn/S\nfirsthand\nfirth/M\nfirths\nfiscal/YS\nfish/JGZMSRD\nfishbowl/MS\nfishcake/S\nfisher/M\nfisherman/M\nfishermen/M\nfishery/MS\nfishhook/MS\nfishily\nfishiness/MS\nfishing/M\nfishmeal\nfishmonger/MS\nfishnet/SM\nfishpond/SM\nfishtail/DMGS\nfishtanks\nfishwife/M\nfishwives\nfishy/TPR\nfissile\nfission/BSDMG\nfissionable/S\nfissure/MGSD\nfist/MDGS\nfistfight/SM\nfistful/MS\nfisticuff/SM\nfistula/SM\nfistulous\nfit's/K\nfit/UYPS\nfitful/PY\nfitfulness/SM\nfitments\nfitness/USM\nfits/AK\nfitted/UA\nfitter/SM\nfittest\nfitting/AU\nfittingly\nfittingness/M\nfittings\nfive/MRS\nfivefold\nfiver/M\nfix/USDG\nfixable\nfixate/VNGXSD\nfixatifs\nfixation/M\nfixative/S\nfixed/YP\nfixedness/M\nfixer/SM\nfixes/I\nfixing/SM\nfixity/MS\nfixture/SM\nfizz/SRDG\nfizzer/M\nfizzle/GSD\nfizzy/RT\nfjord/SM\nfl/GJD\nflab/MS\nflabbergast/GSD\nflabbergasting/Y\nflabbily\nflabbiness/SM\nflabby/TPR\nflaccid/Y\nflaccidity/MS\nflack/SGDM\nflag/MS\nflagella/M\nflagellate/DSNGX\nflagellation/M\nflagellum/M\nflagged\nflagging/SMY\nflaggingly/U\nflagman/M\nflagmen\nflagon/SM\nflagpole/SM\nflagrance/MS\nflagrancy/SM\nflagrant/Y\nflagship/MS\nflagstaff/MS\nflagstone/SM\nflail/SGMD\nflair/SM\nflak/RDMGS\nflake/SM\nflaker/M\nflakiness/MS\nflaky/PRT\nflam/MRNDJGZ\nflambeing\nflambes\nflamboyance/MS\nflamboyancy/MS\nflamboyant/YS\nflamb/D\nflame's\nflame/SIGDR\nflamen/M\nflamenco/SM\nflameproof/DGS\nflamer/IM\nflamethrower/SM\nflaming/Y\nflamingo/SM\nflammability/ISM\nflammable/SI\nflan/MS\nflange/GMSD\nflank/SGZRDM\nflanker/M\nflannel/DMGS\nflannelet/MS\nflannelette's\nflap/MS\nflapjack/SM\nflapped\nflapper/SM\nflapping\nflaps/M\nflare/SDG\nflareup/S\nflaring/Y\nflash/JMRSDGZ\nflashback/SM\nflashbulb/SM\nflashcard/S\nflashcube/MS\nflasher/M\nflashgun/S\nflashily\nflashiness/SM\nflashing/M\nflashlight/MS\nflashy/TPR\nflask/SM\nflat/MYPS\nflatbed/S\nflatboat/MS\nflatcar/MS\nflatfeet\nflatfish/SM\nflatfoot/SGDM\nflathead/M\nflatiron/SM\nflatland/RS\nflatmate/M\nflatness/MS\nflatted\nflatten/SDRG\nflattener/M\nflatter/DRSZG\nflatterer/M\nflattering/YU\nflattery/SM\nflattest/M\nflatting\nflattish\nflattop/MS\nflatulence/SM\nflatulent/Y\nflatus/SM\nflatware/MS\nflatworm/SM\nflaunt/SDG\nflaunting/Y\nflautist/SM\nflavor/SJDRMZG\nflavored/U\nflavorer/M\nflavorful\nflavoring/M\nflavorless\nflavorsome\nflaw/GDMS\nflawless/PY\nflawlessness/MS\nflax/MSN\nflaxseed/M\nflay/RDGZS\nflayer/M\nflea/SM\nfleabag/MS\nfleabites\nfleawort/M\nfleck/GRDMS\nfledge/GSD\nfledged/U\nfledgling/SM\nflee/RS\nfleece/RSDGMZ\nfleecer/M\nfleeciness/SM\nfleecy/RTP\nfleeing\nfleet/MYRDGTPS\nfleeting/YP\nfleetingly/M\nfleetingness/SM\nfleetness/MS\nflesh/JMYRSDG\nflesher/M\nfleshiness/M\nfleshless\nfleshly/TR\nfleshpot/SM\nfleshy/TPR\nfletch/DRSGJ\nfletcher/M\nfletching/M\nflew/S\nflews/M\nflex/MSDAG\nflexed/I\nflexibility/MSI\nflexible/I\nflexibly/I\nflexitime's\nflextime/S\nflexural\nflexure/M\nflibbertigibbet/MS\nflick/GZSRD\nflicker/GD\nflickering/Y\nflickery\nflier/M\nflight/GMDS\nflightiness/SM\nflightless\nflightpath\nflighty/RTP\nflimflam/MS\nflimflammed\nflimflamming\nflimsily\nflimsiness/MS\nflimsy/PTRS\nflinch/GDRS\nflincher/M\nflinching/U\nfling/RMG\nflinger/M\nflint/MDSG\nflintiness/M\nflintless\nflintlock/MS\nflinty/TRP\nflip/S\nflipflop\nflippable\nflippancy/MS\nflippant/Y\nflipped\nflipper/SM\nflippest\nflipping\nflirt/GRDS\nflirtation/SM\nflirtatious/PY\nflirtatiousness/MS\nflit/S\nflitted\nflitting\nfloat/SRDGJZ\nfloater/M\nfloaty\nflocculate/GNDS\nflocculation/M\nflock/SJDMG\nfloe/MS\nflog/S\nflogged\nflogger/SM\nflogging/SM\nflood/SMRDG\nfloodgate/MS\nfloodlight/DGMS\nfloodlit\nfloodplain/S\nfloodwater/SM\nfloor/SJRDMG\nfloorboard/MS\nfloorer/M\nflooring/M\nfloorspace\nfloorwalker/SM\nfloozy/SM\nflop/MS\nflophouse/SM\nflopped\nflopper/M\nfloppily\nfloppiness/SM\nflopping\nfloppy/TMRSP\nflora/SM\nfloral/SY\nflorescence/MIS\nflorescent/I\nfloret/MS\nflorid/YP\nfloridness/SM\nflorin/MS\nflorist/MS\nfloss/GSDM\nflossy/RST\nflotation/SM\nflotilla/SM\nflotsam/SM\nflounce/GDS\nflouncing/M\nflouncy/RT\nflounder/SDG\nflour/SGDM\nflourish/GSRD\nflourisher/M\nflourishing/Y\nfloury/TR\nflout/GZSRD\nflouter/M\nflow/ISG\nflowchart/SG\nflowed\nflower's\nflower/CSGD\nflowerbed/SM\nflowerer/M\nfloweriness/SM\nflowerless\nflowerpot/MS\nflowery/TRP\nflowing/Y\nflown\nflowstone\nflt\nflu/MS\nflub/S\nflubbed\nflubbing\nfluctuate/XSDNG\nfluctuation/M\nflue/SM\nfluency/MS\nfluent/SF\nfluently\nfluff/SGDM\nfluffiness/SM\nfluffy/PRT\nfluid/MYSP\nfluidity/SM\nfluidized\nfluidness/M\nfluke/SDGM\nfluky/RT\nflume/SDGM\nflummox/DSG\nflung\nflunk/SRDG\nflunkey's\nflunky/MS\nfluoresce/GSRD\nfluorescence/MS\nfluorescent/S\nfluoridate/XDSGN\nfluoridation/M\nfluoride/SM\nfluorimetric\nfluorinated\nfluorine/SM\nfluorite/MS\nfluorocarbon/MS\nfluoroscope/MGDS\nfluoroscopic\nflurry/GMDS\nflush/TRSDPBG\nflushness/M\nfluster/DSG\nflute/SRDGMJ\nfluter/M\nfluting/M\nflutist/MS\nflutter/DRSG\nflutterer/M\nfluttery\nflux/IMS\nfluxed/A\nfluxes/A\nfluxing\nfly/JGBDRSTZ\nflyaway\nflyblown\nflyby/M\nflybys\nflycatcher/MS\nflyer's\nflyleaf/M\nflyleaves\nflyover/MS\nflypaper/MS\nflysheet/S\nflyspeck/MDGS\nflyswatter/S\nflyway/MS\nflyweight/MS\nflywheel/MS\nfoal/MDSG\nfoam/MRDSG\nfoaminess/MS\nfoamy/RPT\nfob/SM\nfobbed\nfobbing\nfocal/F\nfocally\nfoci/M\nfocus/SRDMBG\nfocused/AU\nfocuser/M\nfocuses/A\nfodder/GDMS\nfoe/SM\nfoetid\nfog/SM\nfogbound\nfogged/C\nfoggily\nfogginess/MS\nfogging/C\nfoggy/RPT\nfoghorn/SM\nfogs/C\nfogy/SM\nfogyish\nfoible/MS\nfoil/GSD\nfoist/GDS\nfol/Y\nfold/RDJSGZ\nfoldable/U\nfoldaway/S\nfolded/AU\nfolder/M\nfoldout/MS\nfolds/UA\nfoliage/MSD\nfoliate/CSDXGN\nfoliation/CM\nfolio/SDMG\nfolk/MS\nfolklike\nfolklore/MS\nfolkloric\nfolklorist/SM\nfolksiness/MS\nfolksinger/S\nfolksinging/S\nfolksong/S\nfolksy/TPR\nfolktale/S\nfolkway/S\nfoll\nfollicle/SM\nfollicular\nfollow/JSZBGRD\nfollower/M\nfollowup's\nfolly/SM\nfoment/RDSG\nfomentation/SM\nfomenter/M\nfond/PMYRDGTS\nfondant/SM\nfondle/GSRD\nfondler/M\nfondness/MS\nfondue/MS\nfont/MS\nfontanel/MS\nfontanelle's\nfood/MS\nfoodie/S\nfoodstuff/MS\nfool/MDGS\nfoolery/MS\nfoolhardily\nfoolhardiness/SM\nfoolhardy/PTR\nfoolish/PRYT\nfoolishness/SM\nfoolproof\nfoolscap/MS\nfoot/SMRDGZJ\nfootage/SM\nfootball/SRDMGZ\nfootbridge/SM\nfooter/M\nfootfall/SM\nfoothill/SM\nfoothold/MS\nfooting/M\nfootless\nfootlights\nfootling\nfootlocker/SM\nfootloose\nfootman/M\nfootmarks\nfootmen\nfootnote/MSDG\nfootpad/SM\nfootpath/M\nfootpaths\nfootplate/M\nfootprint/MS\nfootrace/S\nfootrest/MS\nfootsie/SM\nfootsore\nfootstep/SM\nfootstool/SM\nfootwear/M\nfootwork/SM\nfop/MS\nfopped\nfoppery/MS\nfopping\nfoppish/YP\nfoppishness/SM\nfor/HT\nforage/GSRDMZ\nforager/M\nforay/SGMRD\nforayer/M\nforbade\nforbear/MRSG\nforbearance/SM\nforbearer/M\nforbid/S\nforbidden\nforbidding/YPS\nforbiddingness/M\nforbore\nforborne\nforce/SRDGM\nforced/Y\nforcefield/MS\nforceful/PY\nforcefulness/MS\nforceps/M\nforcer/M\nforcible/P\nforcibleness/M\nforcibly\nford/SMDBG\nfordable/U\nfore/S\nforearm/GSDM\nforebear/MS\nforebode/GJDS\nforeboding/PYM\nforebodingness/M\nforecast/SZGR\nforecaster/M\nforecastle/MS\nforeclose/GSD\nforeclosure/MS\nforecourt/SM\nforedoom/SDG\nforefather/SM\nforefeet\nforefinger/MS\nforefoot/M\nforefront/SM\nforegoer/M\nforegoing/S\nforegone\nforegos\nforeground/MGDS\nforehand/S\nforehead/MS\nforeign/PRYZS\nforeigner/M\nforeignness/SM\nforeknew\nforeknow/GS\nforeknowledge/MS\nforeknown\nforeleg/MS\nforelimb/MS\nforelock/MDSG\nforeman/M\nforemast/SM\nforemen\nforemost\nforename/DSM\nforenoon/SM\nforensic/S\nforensically\nforensics/M\nforeordain/DSG\nforepart/MS\nforepaws\nforepeople\nforeperson/S\nforeplay/MS\nforequarter/SM\nforerunner/MS\nforesail/SM\nforesaw\nforesee/ZSRB\nforeseeable/U\nforeseeing\nforeseen/U\nforeseer/M\nforeshadow/SGD\nforeshore/M\nforeshorten/DSG\nforesight/SMD\nforesighted/PY\nforesightedness/SM\nforeskin/SM\nforest's\nforest/CSAGD\nforestall/LGSRD\nforestaller/M\nforestallment/M\nforestation/MCS\nforestations/A\nforester/SM\nforestland/S\nforestry/MS\nforetaste/MGSD\nforetell/RGS\nforeteller/M\nforethought/MS\nforetold\nforever/PS\nforevermore\nforewarn/GSJRD\nforewarner/M\nforewent\nforewoman/M\nforewomen\nforeword/SM\nforfeit/ZGDRMS\nforfeiter/M\nforfeiture/MS\nforfend/GSD\nforgather/GSD\nforgave\nforge/JVGMZSRD\nforged/A\nforger/M\nforgery/MS\nforges/A\nforget/SV\nforgetful/PY\nforgetfulness/SM\nforgettable/U\nforgettably/U\nforgetting\nforging/M\nforgivable/U\nforgivably/U\nforgive/SRPBZG\nforgiven\nforgiveness/SM\nforgiver/M\nforgiving/UP\nforgivingly\nforgivingness/M\nforgo/RSGZ\nforgoer/M\nforgoes\nforgone\nforgot\nforgotten/U\nfork/GSRDM\nforkful/S\nforklift/DMSG\nforlorn/PTRY\nforlornness/M\nform's\nform/CGSAFDI\nformability/AM\nformal/IY\nformaldehyde/SM\nformalin/M\nformalism/SM\nformalist/SM\nformalistic\nformality/SMI\nformalization/SM\nformalize/ZGSRD\nformalized/U\nformalizer/M\nformalizes/I\nformalness/M\nformals\nformant/MIS\nformat's\nformat/AVS\nformate/MXGNSD\nformation/AFSCIM\nformative/SYP\nformatively/I\nformativeness/IM\nformatted/UA\nformatter's\nformatter/A\nformatters\nformatting/A\nformed/U\nformer/FSAI\nformerly\nformfitting\nformic\nformidable/P\nformidableness/M\nformidably\nformless/PY\nformlessness/MS\nformula/SM\nformulaic\nformulate/AGNSDX\nformulated/U\nformulation/AM\nformulator/SM\nfornicate/GNXSD\nfornication/M\nfornicator/SM\nforsake/SG\nforsaken\nforsook\nforsooth\nforswear/SG\nforswore\nforsworn\nforsythia/MS\nfort/SM\nforte/MS\nforthcome/JG\nforthcoming/U\nforthright/PYS\nforthrightness/SM\nforthwith\nfortieths\nfortification/MS\nfortified/U\nfortifier/SM\nfortify/ADSG\nfortiori\nfortissimo/S\nfortitude/SM\nfortnight/MYS\nfortnightly/S\nfortress/GMSD\nfortuitous/YP\nfortuitousness/SM\nfortuity/MS\nfortunate/YUS\nfortunateness/M\nfortune/MGSD\nfortuneteller/SM\nfortunetelling/SM\nforty/SRMH\nforum/MS\nforward/PTZSGDRY\nforwarder/M\nforwarding/M\nforwardness/MS\nforwent\nfossil/MS\nfossiliferous\nfossilization/MS\nfossilize/GSD\nfossilized/U\nfoster/SRDG\nfosterer/M\nfought\nfoul/SYRDGTP\nfoulard/SM\nfoulmouth/D\nfoulness/MS\nfouls/M\nfound/RDGZS\nfoundation/SM\nfoundational\nfounded/UF\nfounder's/F\nfounder/MDG\nfounding/F\nfoundling/MS\nfoundry/MS\nfounds/KF\nfount/MS\nfountain/SMDG\nfountainhead/SM\nfour/SHM\nfourfold\nfourpence/M\nfourpenny\nfourposter/SM\nfourscore/S\nfoursome/SM\nfoursquare\nfourteen/SMRH\nfourteener/M\nfourteenths\nfourth/Y\nfourths\nfovea/M\nfowl/SGMRD\nfowler/M\nfowling/M\nfox/MDSG\nfoxfire/SM\nfoxglove/SM\nfoxhole/SM\nfoxhound/SM\nfoxily\nfoxiness/MS\nfoxing/M\nfoxtail/M\nfoxtrot/MS\nfoxtrotted\nfoxtrotting\nfoxy/TRP\nfoyer/SM\nfps\nfr\nfracas/SM\nfractal/SM\nfraction/ISMA\nfractional/Y\nfractionate/DNG\nfractionation/M\nfractioned\nfractioning\nfractious/PY\nfractiousness/SM\nfracture/MGDS\nfragile/Y\nfragility/MS\nfragment/SDMG\nfragmentarily\nfragmentariness/M\nfragmentary/P\nfragmentation/MS\nfragrance/SM\nfragrant/Y\nfrail/STPYR\nfrailness/MS\nfrailty/MS\nframe/SRDJGMZ\nframed/U\nframer/M\nframework/SM\nframing/M\nfranc/SM\nfranchise's\nfranchise/ESDG\nfranchisee/S\nfranchiser/SM\nfrancium/MS\nfrancophone/M\nfrangibility/SM\nfrangible\nfrank/SGTYRDP\nfranker/M\nfrankfurter/MS\nfrankincense/MS\nfranklin/M\nfrankness/MS\nfrantic/PY\nfrantically\nfranticness/M\nfrappeed\nfrappeing\nfrappes\nfrapp\nfrat/MS\nfraternal/Y\nfraternity/MSF\nfraternization/SM\nfraternize/GZRSD\nfraternizer/M\nfraternizing/U\nfratricidal\nfratricide/MS\nfraud's\nfraud/CS\nfraudsters\nfraudulence/S\nfraudulent/YP\nfraught/SGD\nfray's\nfray/CSDG\nfrazzle/GDS\nfreak/SGDM\nfreakish/YP\nfreakishness/SM\nfreaky/RT\nfreckle/GMDS\nfreckly/RT\nfree/YTDRSP\nfreebase/GDS\nfreebie/MS\nfreeboot/ZR\nfreebooter/M\nfreeborn\nfreedman/M\nfreedmen\nfreedom/MS\nfreehand/D\nfreehanded/Y\nfreehold/ZSRM\nfreeholder/M\nfreeing/S\nfreelance/SRDGZM\nfreeload/SRDGZ\nfreeloader/M\nfreeman/M\nfreemasonry/M\nfreemen\nfreeness/M\nfreestanding\nfreestone/SM\nfreestyle/SM\nfreethinker/MS\nfreethinking/S\nfreeway/MS\nfreewheel/SRDMGZ\nfreewheeler/M\nfreewheeling/P\nfreewill\nfreezable\nfreeze/UGSA\nfreezer/SM\nfreezing/S\nfreight/ZGMDRS\nfreighter/M\nfrenetic/S\nfrenetically\nfrenzied/Y\nfrenzy/MDSG\nfreon/S\nfreq\nfrequency/ISM\nfrequent/IY\nfrequented/U\nfrequenter/MS\nfrequentest\nfrequenting\nfrequentness/M\nfrequents\nfresco/DMG\nfrescoes\nfresh/AZSRNDG\nfreshen/SZGDR\nfreshener/M\nfresher/MA\nfreshest\nfreshet/SM\nfreshly\nfreshman/M\nfreshmen\nfreshness/MS\nfreshwater/SM\nfret/S\nfretboard\nfretful/PY\nfretfulness/MS\nfretsaw/S\nfretted\nfretting\nfretwork/MS\nfriable/P\nfriableness/M\nfriar/YMS\nfriary/MS\nfricassee/MSD\nfricasseeing\nfrication/M\nfricative/MS\nfriction/MS\nfrictional/Y\nfrictionless/Y\nfridge/SM\nfried/A\nfriedcake/SM\nfriend/SGMYD\nfriendless/P\nfriendlessness/M\nfriendlies\nfriendlily\nfriendliness/USM\nfriendly/PUTR\nfriendship/MS\nfrier's\nfries/M\nfrieze/SDGM\nfrig/S\nfrigate/SM\nfrigged\nfrigging/S\nfright/GXMDNS\nfrighten/DG\nfrightening/Y\nfrightful/PY\nfrightfulness/MS\nfrigid/YP\nfrigidity/MS\nfrigidness/SM\nfrill/MDGS\nfrilly/RST\nfringe's\nfringe/IGSD\nfrippery/SM\nfrisk/RDGS\nfrisker/M\nfriskily\nfriskiness/SM\nfrisky/RTP\nfrisson/M\nfritter/RDSG\nfritterer/M\nfritz/SM\nfrivolity/MS\nfrivolous/PY\nfrivolousness/SM\nfrizz/GYSD\nfrizzle/DSG\nfrizzly/RT\nfrizzy/RT\nfro/HS\nfrock's\nfrock/SUDGC\nfrocking/M\nfrog/MS\nfrogged\nfrogging\nfrogman/M\nfrogmarched\nfrogmen\nfrolic/SM\nfrolicked\nfrolicker/SM\nfrolicking\nfrolicsome\nfrom\nfrond/SM\nfront's\nfront/GSFRD\nfrontage/MS\nfrontal/SY\nfrontier/SM\nfrontiersman/M\nfrontiersmen\nfrontispiece/SM\nfrontrunner's\nfrontward/S\nfrosh/M\nfrost's\nfrost/CDSG\nfrostbit/G\nfrostbite/MS\nfrostbiting/M\nfrostbitten\nfrosted/U\nfrosteds\nfrostily\nfrostiness/SM\nfrosting/MS\nfrosty/PTR\nfroth/GMD\nfrothiness/SM\nfroths\nfrothy/TRP\nfroufrou/MS\nfroward/P\nfrowardness/MS\nfrown/RDSG\nfrowner/M\nfrowning/Y\nfrowzily\nfrowziness/SM\nfrowzy/RPT\nfroze/UA\nfrozen/YP\nfrozenness/M\nfructify/GSD\nfructose/MS\nfrugal/Y\nfrugality/SM\nfruit/GMRDS\nfruitcake/SM\nfruiter/RM\nfruiterer/M\nfruitful/UYP\nfruitfuller\nfruitfullest\nfruitfulness/MS\nfruitiness/MS\nfruition/SM\nfruitless/YP\nfruitlessness/MS\nfruity/RPT\nfrump/MS\nfrumpish\nfrumpy/TR\nfrustrate/RSDXNG\nfrustrater/M\nfrustrating/Y\nfrustration/M\nfrustum/SM\nfry/NGDS\nfryer/MS\nft/C\nfuchsia/MS\nfuck/GZJRDMS!\nfucker/M!\nfuddle/GSD\nfudge/GMSD\nfuel's\nfuel/ASDG\nfueler/SM\nfugal\nfugitive/SYMP\nfugitiveness/M\nfugue/GMSD\nfuhrer/S\nfulcrum/SM\nfulfill/GLSRD\nfulfilled/U\nfulfiller/M\nfulfillment/MS\nfull/RDPSGZT\nfullback/SMG\nfuller/DMG\nfullish\nfullness/MS\nfullstops\nfullword/SM\nfully\nfulminate/XSDGN\nfulmination/M\nfulness's\nfulsome/PY\nfulsomeness/SM\nfumble/GZRSD\nfumbler/M\nfumbling/Y\nfume/DSG\nfumigant/MS\nfumigate/NGSDX\nfumigation/M\nfumigator/SM\nfuming/Y\nfumy/TR\nfun/MS\nfunction/GSMD\nfunctional/YS\nfunctionalism/M\nfunctionalist/SM\nfunctionality/S\nfunctionary/MS\nfunctor/SM\nfund/ASMRDZG\nfundamental/SY\nfundamentalism/SM\nfundamentalist/SM\nfunded/U\nfundholders\nfundholding\nfunding/S\nfuneral/MS\nfunerary\nfunereal/Y\nfunfair/M\nfungal/S\nfungi/M\nfungible/M\nfungicidal\nfungicide/SM\nfungoid/S\nfungous\nfungus/M\nfunicular/SM\nfunk/GSDM\nfunkiness/S\nfunky/RTP\nfunned\nfunnel/SGMD\nfunner\nfunnest\nfunnily/U\nfunniness/SM\nfunning\nfunny/RSPT\nfur/PMS\nfurbelow/MDSG\nfurbish/GDRSA\nfurbisher/M\nfurious/RYP\nfuriousness/M\nfurl/UDGS\nfurlong/MS\nfurlough/DGM\nfurloughs\nfurn\nfurnace/GMSD\nfurnish/GASD\nfurnished/U\nfurnisher/MS\nfurnishing/SM\nfurniture/SM\nfuror/MS\nfurore/MS\nfurred\nfurrier/M\nfurriness/SM\nfurring/SM\nfurrow/DMGS\nfurry/RTZP\nfurther/TGDRS\nfurtherance/MS\nfurtherer/M\nfurthermore\nfurthermost\nfurthest\nfurtive/PY\nfurtiveness/SM\nfury/SM\nfurze/SM\nfuse's/A\nfuse/FSDAGCI\nfusebox/S\nfusee/SM\nfuselage/SM\nfusibility/SM\nfusible/I\nfusiform\nfusilier/MS\nfusillade/SDMG\nfusion/KMFSI\nfuss/SRDMG\nfussbudget/MS\nfusser/M\nfussily\nfussiness/MS\nfusspot/SM\nfussy/PTR\nfustian/MS\nfustiness/MS\nfusty/RPT\nfut\nfutile/PY\nfutileness/M\nfutility/MS\nfuton/S\nfuture/SM\nfuturism/SM\nfuturist/S\nfuturistic/S\nfuturity/MS\nfuturologist/S\nfuturology/MS\nfutz/GSD\nfuze's\nfuzz/SDMG\nfuzzily\nfuzziness/SM\nfuzzy/PRT\nfwd\nfwy\nfte/MS\ng's\ng/VBX\ngab/S\ngabardine/SM\ngabbed\ngabbiness/S\ngabbing\ngabble/SDG\ngabby/TRP\ngaberdine's\ngabfest/MS\ngable/GMSRD\ngad/S\ngadabout/MS\ngadded\ngadder/MS\ngadding\ngadfly/MS\ngadget/SM\ngadgetry/MS\ngadolinium/MS\ngaff/SGZRDM\ngaffe/MS\ngaffer/M\ngag/DRSG\ngaga\ngage/SM\ngager/M\ngagged\ngagging\ngaggle/SDG\ngagwriter/S\ngaiety/MS\ngaily\ngain/ADGS\ngainer/SM\ngainful/YP\ngainfulness/M\ngaining/S\ngainly/U\ngainsaid\ngainsay/RSZG\ngainsayer/M\ngait/GSZMRD\ngaiter/M\ngal's\ngal/AS\ngala/SM\ngalactic\ngalaxy/MS\ngale's\ngale/AS\ngalen\ngalena/MS\ngalenite/M\ngall/SGMD\ngallant/UY\ngallanted\ngallanting\ngallantry/MS\ngallants\ngallbladder/MS\ngalleon/SM\ngalleria/S\ngallery/MSDG\ngalley/MS\ngallimaufry/MS\ngalling/Y\ngallium/SM\ngallivant/GDS\ngallon/SM\ngallonage/M\ngallop/GSRDZ\ngalloper/M\ngallows/M\ngallstone/MS\ngaloot/MS\ngalore/S\ngalosh/GMSD\ngalumph/GD\ngalumphs\ngalvanic\ngalvanism/MS\ngalvanization/SM\ngalvanize/SDG\ngalvanometer/SM\ngalvanometric\ngambit/MS\ngamble/GZRSD\ngambler/M\ngambol/SGD\ngame/PJDRSMYTZG\ngamecock/SM\ngamekeeper/MS\ngameness/MS\ngamesmanship/SM\ngamesmen\ngamest/RZ\ngamester/M\ngamete/MS\ngametic\ngamin/MS\ngamine/SM\ngaminess/MS\ngaming/M\ngamma/MS\ngammon/DMSG\ngamut/MS\ngamy/TRP\ngander/DMGS\ngang/GRDMS\ngangbusters\nganger/M\ngangland/SM\nganglia/M\ngangling\nganglion/M\nganglionic\ngangplank/SM\ngangrene/SDMG\ngangrenous\ngangster/SM\ngangway/MS\ngannet/SM\ngantlet/GMDS\ngantry/MS\ngaol/MRDGZS\ngaoler/M\ngap/SJMDRG\ngape/S\ngaper/M\ngaping/Y\ngapped\ngapping\ngar/SLM\ngarage/GMSD\ngarb/DMGS\ngarbage/SDMG\ngarbageman/M\ngarbanzo/MS\ngarble/RSDG\ngarbler/M\ngarden/ZGRDMS\ngardener/M\ngardenia/SM\ngardening/M\ngarfish/MS\ngargantuan\ngargle/SDG\ngargoyle/DSM\ngarish/YP\ngarishness/MS\ngarland/SMDG\ngarlic/SM\ngarlicked\ngarlicking\ngarlicky\ngarment/MDGS\ngarner/SGD\ngarnet/SM\ngarnish/DSLG\ngarnishee/SDM\ngarnisheeing\ngarnishment/MS\ngarote's\ngarotte's\ngarred\ngarret/SM\ngarring\ngarrison/SGMD\ngarrote/SRDMZG\ngarroter/M\ngarrotte's\ngarrulity/SM\ngarrulous/PY\ngarrulousness/MS\ngarter/SGDM\ngaron/SM\ngas's\ngas/FC\ngasbag/MS\ngaseous/YP\ngaseousness/M\ngases/C\ngash/GTMSRD\ngasification/M\ngasifier/M\ngasify/SRDGXZN\ngasket/SM\ngaslight/DMS\ngasohol/S\ngasoline/MS\ngasometer/M\ngasp/GZSRD\ngasper/M\ngasping/Y\ngassed/C\ngasser/MS\ngassiness/M\ngassing/SM\ngassy/PTR\ngastric\ngastritides\ngastritis/MS\ngastroenteritides\ngastroenteritis/M\ngastrointestinal\ngastronome/SM\ngastronomic\ngastronomical/Y\ngastronomy/MS\ngastropod/SM\ngasworks/M\ngate/MGDS\ngateau/MS\ngateaux\ngatecrash/GZSRD\ngatehouse/MS\ngatekeeper/SM\ngatepost/SM\ngateway/MS\ngather/JRDZGS\ngathered/IA\ngatherer/M\ngathering/M\ngathers/A\ngator/MS\ngauche/TYPR\ngaucheness/SM\ngaucherie/SM\ngaucho/SM\ngaudily\ngaudiness/MS\ngaudy/PRST\ngauge/SM\ngaugeable\ngauger/M\ngaunt/PYRDSGT\ngauntlet/GSDM\ngauntness/MS\ngauss's\ngauss/C\ngausses\ngauze/SDGM\ngauziness/MS\ngauzy/TRP\ngave\ngavel/GMDS\ngavotte/MSDG\ngawk/SGRDM\ngawkily\ngawkiness/MS\ngawky/RSPT\ngay/RTPS\ngayety's\ngayness/SM\ngaze/DRSZG\ngazebo/SM\ngazelle/MS\ngazer/M\ngazette/MGSD\ngazetteer/SGDM\ngazillion/S\ngazpacho/MS\ngear/DMJSG\ngearbox/SM\ngearing/M\ngearshift/MS\ngearstick\ngearwheel/SM\ngecko/MS\ngee/TDS\ngeegaw's\ngeeing\ngeek/SM\ngeeky/RT\ngeese/M\ngeest/M\ngeezer/MS\ngeisha/M\ngel/MBS\ngelatin/SM\ngelatinous/PY\ngelatinousness/M\ngelcap\ngeld/JSGD\ngelding/M\ngelid\ngelignite/MS\ngelled\ngelling\ngem/MS\ngemlike\ngemmed\ngemming\ngemological\ngemologist/MS\ngemology/MS\ngemstone/SM\ngen\ngendarme/MS\ngender/DMGS\ngenderless\ngene/MS\ngenealogical/Y\ngenealogist/SM\ngenealogy/MS\ngenera/M\ngeneral/MSPY\ngeneralissimo/SM\ngeneralist/MS\ngenerality/MS\ngeneralizable/SM\ngeneralization/MS\ngeneralize/GZBSRD\ngeneralized/U\ngeneralizer/M\ngeneralness/M\ngeneralship/SM\ngenerate/CXAVNGSD\ngeneration/MCA\ngenerational\ngenerative/AY\ngenerator/SM\ngenerators/A\ngeneric/PS\ngenerically\ngenerosity/MS\ngenerous/PY\ngenerously/U\ngenerousness/SM\ngenes/S\ngenesis/M\ngenetic/S\ngenetically\ngeneticist/MS\ngenetics/M\ngenial/PY\ngeniality/FMS\ngenially/F\ngenialness/M\ngenie/SM\ngenies/K\ngenii/M\ngenital/YF\ngenitalia\ngenitals\ngenitive/SM\ngenitourinary\ngenius/SM\ngenocidal\ngenocide/SM\ngenome/SM\ngenotype/MS\ngenre/MS\ngent/AMS\ngenteel/PRYT\ngenteelness/MS\ngentian/SM\ngentile/S\ngentility/MS\ngentle/PRSDGT\ngentlefolk/S\ngentleman/YM\ngentlemanliness/M\ngentlemanly/U\ngentlemen\ngentleness/SM\ngentlewoman/M\ngentlewomen/M\ngently\ngentrification/M\ngentrify/NSDGX\ngentry/MS\ngenuflect/GDS\ngenuflection/MS\ngenuine/PY\ngenuineness/SM\ngenus\ngeocentric\ngeocentrically\ngeocentricism\ngeochemical/Y\ngeochemistry/MS\ngeochronology/M\ngeode/SM\ngeodesic/S\ngeodesy/MS\ngeodetic/S\ngeog\ngeographer/MS\ngeographic\ngeographical/Y\ngeography/MS\ngeologic\ngeological/Y\ngeologist/MS\ngeology/MS\ngeom\ngeomagnetic\ngeomagnetically\ngeomagnetism/SM\ngeometer/MS\ngeometric/S\ngeometrical/Y\ngeometrician/M\ngeometry/MS\ngeomorphological\ngeomorphology/M\ngeophysical/Y\ngeophysicist/MS\ngeophysics/M\ngeopolitic/S\ngeopolitical/Y\ngeopolitics/M\ngeostationary\ngeosynchronous\ngeosyncline/SM\ngeothermal\ngeothermic\ngeranium/SM\ngerbil/MS\ngeriatric/S\ngeriatrics/M\ngerm/MNS\ngermane\ngermanium/SM\ngermanized\ngermen/M\ngermicidal\ngermicide/MS\ngerminal/Y\ngerminate/XVGNSD\ngerminated/U\ngermination/M\ngerminative/Y\ngerontocracy/M\ngerontological\ngerontologist/SM\ngerontology/SM\ngerrymander/SGD\ngerund/SVM\ngerundive/M\ngestalt/M\ngestapo/S\ngestate/SDGNX\ngestation/M\ngestational\ngesticulate/XSDVGN\ngesticulation/M\ngesticulative/Y\ngestural\ngesture/SDMG\ngesundheit\nget/S\ngetaway/SM\ngetter/SDM\ngetting\ngetup/MS\ngewgaw/MS\ngeyser/GDMS\nghastliness/MS\nghastly/TPR\nghat/MS\ngherkin/SM\nghetto/DGMS\nghettoize/SDG\nghost/SMYDG\nghostlike\nghostliness/MS\nghostly/TRP\nghostwrite/RSGZ\nghostwritten\nghostwrote\nghoul/SM\nghoulish/PY\nghoulishness/SM\ngiant/SM\ngiantess/MS\ngiantkiller\ngibber/DGS\ngibberish/MS\ngibbet/MDSG\ngibbon/MS\ngibbous/YP\ngibbousness/M\ngibe/GDRS\ngiber/M\ngiblet/MS\ngiddap\ngiddily\ngiddiness/SM\ngiddy/GPRSDT\ngift/SGMD\ngifted/PY\ngiftedness/M\ngig/MS\ngigabyte/S\ngigacycle/MS\ngigahertz/M\ngigantic/P\ngigantically\ngiganticness/M\ngigavolt\ngigawatt/M\ngigged\ngigging\ngiggle/RSDGZ\ngiggler/M\ngiggling/Y\ngiggly/TR\ngigolo/MS\ngila\ngilbert/M\ngild/JSGZRD\ngilder/M\ngilding/M\ngill/SGMRD\ngilt/S\ngimbaled\ngimbals\ngimcrack/S\ngimcrackery/SM\ngimlet/MDSG\ngimme/S\ngimmick/GDMS\ngimmickry/MS\ngimmicky\ngimp/GSMD\ngimpy/RT\ngin/MS\nginger/SGDYM\ngingerbread/SM\ngingerliness/M\ngingerly/P\ngingersnap/SM\ngingery\ngingham/SM\ngingivitis/SM\nginkgo/M\nginkgoes\nginmill\nginned\nginning\nginseng/SM\ngiraffe/MS\ngird/RDSGZ\ngirded/U\ngirder/M\ngirdle/GMRSD\ngirdler/M\ngirl/MS\ngirlfriend/MS\ngirlhood/SM\ngirlie/M\ngirlish/YP\ngirlishness/SM\ngiro/M\ngirt/GDS\ngirth/MDG\ngirths\ngist/MS\ngit/M\ngive/HZGRS\ngiveaway/SM\ngiveback/S\ngiven/SP\ngiver/M\ngiving/Y\ngizmo's\ngizzard/SM\nglacial/Y\nglaciate/XNGDS\nglaciation/M\nglacier/SM\nglaciological\nglaciologist/M\nglaciology/M\nglac/DGS\nglad/YSP\ngladded\ngladden/GDS\ngladder\ngladdest\ngladding\ngladdy\nglade/SM\ngladiator/SM\ngladiatorial\ngladiola/MS\ngladioli\ngladiolus/M\ngladly/RT\ngladness/MS\ngladsome/RT\nglamor/DMGS\nglamorization/MS\nglamorize/SRDZG\nglamorizer/M\nglamorous/PY\nglamorousness/M\nglance/GJSD\nglancing/Y\ngland/ZSM\nglanders/M\nglandes\nglandular/Y\nglans/M\nglare/SDG\nglaring/YP\nglaringness/M\nglasnost/S\nglass/GSDM\nglassblower/S\nglassblowing/MS\nglassful/MS\nglasshouse/SM\nglassily\nglassiness/SM\nglassless\nglassware/SM\nglasswort/M\nglassy/PRST\nglaucoma/SM\nglaucous\nglaze/SRDGZJ\nglazed/U\nglazer/M\nglazier/SM\nglazing/M\ngleam/MDGS\nglean/RDGZJS\ngleaner/M\ngleaning/M\nglee/DSM\ngleed/M\ngleeful/YP\ngleefulness/MS\ngleeing\nglen/SM\nglib/YP\nglibber\nglibbest\nglibness/MS\nglide/JGZSRD\nglider/M\nglim/M\nglimmer/DSJG\nglimmering/M\nglimpse/DRSZMG\nglimpser/M\nglint/DSG\nglissandi\nglissando/M\nglisten/DSG\nglister/DGS\nglitch/MS\nglitter/GDSJ\nglittering/Y\nglittery\nglitz/GSD\nglitzy/TR\ngloaming/MS\ngloat/SRDG\ngloater/M\ngloating/Y\nglob/GDMS\nglobal/SY\nglobalism/S\nglobalist/S\nglobe/SM\nglobetrotter/MS\nglobular/PY\nglobularity/M\nglobularness/M\nglobule/MS\nglobulin/MS\nglockenspiel/SM\nglommed\ngloom/GSMD\ngloomily\ngloominess/MS\ngloomy/RTP\nglop/MS\nglopped\nglopping\ngloppy/TR\nglorification/M\nglorifier/M\nglorify/XZRSDNG\nglorious/IYP\ngloriousness/IM\nglory/SDMG\ngloss/GSDM\nglossary/MS\nglossily\nglossiness/SM\nglossolalia/SM\nglossy/RSPT\nglottal\nglottalization/M\nglottis/MS\nglove/SRDGMZ\ngloveless\nglover/M\nglow/GZRDMS\nglower/GD\nglowing/Y\nglowworm/SM\nglucose/SM\nglue/DRSMZG\nglued/U\ngluer/M\ngluey\ngluier\ngluiest\nglum/SYP\nglummer\nglummest\nglumness/MS\ngluon/M\nglut/SMNX\nglutamate/M\ngluten/M\nglutenous\nglutinous/PY\nglutinousness/M\nglutted\nglutting\nglutton/MS\ngluttonous/Y\ngluttony/SM\nglyceride/M\nglycerin/SM\nglycerinate/MD\nglycerine's\nglycerol/SM\nglycerolized/C\nglycine/M\nglycogen/SM\nglycol/MS\nglyph/M\nglyphs\ngm\ngnarl/SMDG\ngnash/SDG\ngnat/MS\ngnaw/GRDSJ\ngnawer/M\ngnawing/M\ngneiss/SM\ngnome/SM\ngnomelike\ngnomic\ngnomish\ngnomonic\ngnostic/K\ngnosticism\ngnu/MS\ngo/MRHZGJ\ngoad/MDSG\ngoal/MDSG\ngoalie/SM\ngoalkeeper/MS\ngoalkeeping/M\ngoalless\ngoalmouth/M\ngoalpost/S\ngoalscorer\ngoalscoring\ngoaltender/SM\ngoat/MS\ngoatee/SM\ngoatherd/MS\ngoatskin/SM\ngob/SM\ngobbed\ngobbet/MS\ngobbing\ngobble/SRDGZ\ngobbledegook's\ngobbledygook/S\ngobbler/M\ngoblet/MS\ngoblin/SM\ngod/SMY\ngodchild/M\ngodchildren\ngoddammit\ngoddamn/GS\ngoddaughter/SM\ngodded\ngoddess/MS\ngodding\ngodfather/GSDM\ngodforsaken\ngodhead/S\ngodhood/SM\ngodless/P\ngodlessness/MS\ngodlike/P\ngodlikeness/M\ngodliness/UMS\ngodly/UTPR\ngodmother/MS\ngodparent/SM\ngodsend/MS\ngodson/MS\ngoer/MG\ngoes\ngofer/SM\ngoggle/SRDGZ\ngoggler/M\ngoing/M\ngoiter/SM\ngold/MRNGTS\ngoldbrick/GZRDMS\ngoldbricker/M\ngolden/TRYP\ngoldenness/M\ngoldenrod/SM\ngoldenseal/M\ngoldfinch/MS\ngoldfish/SM\ngoldmine/S\ngoldsmith/M\ngoldsmiths\ngolf/RDMGZS\ngolfer/M\ngolly/S\ngonad/SM\ngonadal\ngondola/SM\ngondolier/MS\ngone/RZN\ngoner/M\ngong/SGDM\ngonion/M\ngonna\ngonorrhea/MS\ngonorrheal\ngoo/MS\ngoober/MS\ngood/SYP\ngoodbye/MS\ngoodhearted\ngoodie's\ngoodish\ngoodly/TR\ngoodness/MS\ngoodnight\ngoodwill/MS\ngoody/SM\ngooey\ngoof/SDMG\ngoofiness/MS\ngoofy/RPT\ngooier\ngooiest\ngook/SM\ngoon/SM\ngoop/SM\ngoos/SDG\ngoose/M\ngooseberry/MS\ngoosebumps\ngopher/SM\ngore/DSMG\ngorge/GMSRD\ngorged/E\ngorgeous/YP\ngorgeousness/SM\ngorger/EM\ngorges/E\ngorging/E\ngorgon/S\ngorilla/MS\ngorily\ngoriness/MS\ngoring/M\ngormandize/SRDGZ\ngormandizer/M\ngormless\ngorp/S\ngorse/SM\ngory/PRT\ngos\ngosh/S\ngoshawk/MS\ngosling/M\ngospel/MRSZ\ngospeler/M\ngossamer/SM\ngossip/ZGMRDS\ngossipy\ngot/IU\ngotcha/SM\ngoto\ngotta\ngotten/U\ngouge/GZSRD\ngouger/M\ngoulash/SM\ngourd/MS\ngourde/SM\ngourmand/MS\ngourmet/MS\ngout/SM\ngouty/RT\ngov/S\ngovern/LBGSD\ngovernable/U\ngovernance/SM\ngoverned/U\ngoverness/SM\ngovernment/MS\ngovernmental/Y\ngovernor/MS\ngovernorship/SM\ngovt\ngown/GSDM\ngr\ngrab/S\ngrabbed\ngrabber/SM\ngrabbing/S\ngrace/ESDMG\ngraceful/EYPU\ngracefuller\ngracefullest\ngracefulness/ESM\ngraceless/PY\ngracelessness/MS\ngracious/UY\ngraciousness/SM\ngrackle/SM\ngrad/MRDGZJS\ngradate/DSNGX\ngradation/MCS\ngrade's\ngrade/ACSDG\ngraded/U\ngradely\ngrader/MC\ngradient/RMS\ngradual/SYP\ngradualism/MS\ngradualist/MS\ngradualness/MS\ngraduand/SM\ngraduate/MNGDSX\ngraduation/M\ngraffiti\ngraffito/M\ngraft/MRDSGZ\ngrafter/M\ngrafting/M\ngraham/SM\ngrail/S\ngrain's\ngrain/IGSD\ngrainer/M\ngraininess/MS\ngraining/M\ngrainy/RTP\ngram/KSM\ngrammar/MS\ngrammarian/SM\ngrammatic/K\ngrammatical/UY\ngrammaticality/M\ngrammaticalness/M\ngramme/SM\ngramophone/SM\ngrampus/SM\ngranary/MS\ngrand/TPSYR\ngrandam/SM\ngrandaunt/MS\ngrandchild/M\ngrandchildren\ngranddad/SM\ngranddaddy/MS\ngranddaughter/MS\ngrandee/SM\ngrandeur/MS\ngrandfather/MYDSG\ngrandiloquence/SM\ngrandiloquent/Y\ngrandiose/YP\ngrandiosity/MS\ngrandkid/SM\ngrandma/MS\ngrandmaster/MS\ngrandmother/MYS\ngrandnephew/MS\ngrandness/MS\ngrandniece/SM\ngrandpa/MS\ngrandparent/MS\ngrandson/MS\ngrandstand/SRDMG\ngrandstander/M\ngranduncle/MS\ngrange/MSR\ngranite/MS\ngranitic\ngranny/MS\ngranola/S\ngrant/SGZMRD\ngrantee/MS\ngranter/M\ngrantor's\ngrantsmanship/S\ngranular/Y\ngranularity/SM\ngranulate/SDXVGN\ngranulation/M\ngranule/SM\ngranulocytic\ngrape/SDGM\ngrapefruit/SM\ngrapeshot/M\ngrapevine/MS\ngraph/GMD\ngrapheme/M\ngraphic/PS\ngraphical/Y\ngraphicness/M\ngraphics/M\ngraphite/SM\ngraphologist/SM\ngraphology/MS\ngraphs\ngrapnel/SM\ngrapple/DRSG\ngrappler/M\ngrappling/M\ngrasp/SRDBG\ngrasper/M\ngrasping/PY\ngraspingness/M\ngrass/GZSDM\ngrasshopper/SM\ngrassland/MS\ngrassroots\ngrassy/RT\ngrate/SRDJGZ\ngrateful/YPU\ngratefuller\ngratefullest\ngratefulness/USM\ngrater/M\ngrates/I\ngraticule/M\ngratification/M\ngratified/U\ngratify/NDSXG\ngratifying/Y\ngrating/YM\ngratis\ngratitude/IMS\ngratuitous/PY\ngratuitousness/MS\ngratuity/SM\ngravamen/SM\ngrave/SRDPGMZTY\ngravedigger/SM\ngravel/SGMYD\ngraven\ngraveness/MS\ngraver/M\ngraveside/S\ngravestone/SM\ngraveyard/MS\ngravid/PY\ngravidness/M\ngravimeter/SM\ngravimetric\ngravitas\ngravitate/XVGNSD\ngravitation/M\ngravitational/Y\ngraviton/SM\ngravity/MS\ngravy/SM\ngray/PYRDGTS\ngraybeard/MS\ngrayish\ngrayness/S\ngraze/GZSRD\ngrazer/M\ngrazing/M\ngrease/GMZSRD\ngreasepaint/MS\ngreaseproof\ngreaser/M\ngreasily\ngreasiness/SM\ngreasy/PRT\ngreat/SPTYRN\ngreatcoat/DMS\ngreaten/DG\ngreathearted\ngreatness/MS\ngrebe/MS\ngreed's\ngreed/C\ngreedily\ngreediness/SM\ngreeds\ngreedy/RTP\ngreen/SYRDMPGT\ngreenback/MS\ngreenbelt/S\ngreenery/MS\ngreenfield\ngreenfly/M\ngreengage/SM\ngreengrocer/SM\ngreengrocery/M\ngreenhorn/SM\ngreenhouse/SM\ngreening/M\ngreenish/P\ngreenmail/GDS\ngreenness/MS\ngreenroom/SM\ngreensward/SM\ngreenwood/MS\ngreet/SRDJGZ\ngreeter/M\ngreeting/M\ngreets/A\ngregarious/PY\ngregariousness/MS\ngremlin/SM\ngrenade/MS\ngrenadier/SM\ngrenadine/SM\ngrew/A\ngreybeard/M\ngreyhound/MS\ngreyness/M\ngrid/SGM\ngridded\ngriddle/DSGM\ngriddlecake/SM\ngridiron/GSMD\ngridlock/DSG\ngrids/A\ngrief/MS\ngrievance/SM\ngrieve/SRDGZ\ngriever/M\ngrieving/Y\ngrievous/PY\ngrievousness/SM\ngriffin/SM\ngriffon's\ngrill/RDGS\ngrille/SM\ngriller/M\ngrillwork/M\ngrim/PGYD\ngrimace/DRSGM\ngrimacer/M\ngrime/MS\ngriminess/MS\ngrimmer\ngrimmest\ngrimness/MS\ngrimy/TPR\ngrin/S\ngrind/ASG\ngrinder/MS\ngrinding/SY\ngrindstone/SM\ngringo/SM\ngrinned\ngrinner/M\ngrinning/Y\ngrip/SGZMRD\ngripe/S\ngriper/M\ngrippe/GMZSRD\ngripper/M\ngripping/Y\ngrisliness/SM\ngrisly/RPT\ngrist/MYS\ngristle/SM\ngristliness/M\ngristly/TRP\ngristmill/MS\ngrit/MS\ngritted\ngritter/MS\ngrittiness/SM\ngritting\ngritty/PRT\ngrizzle/DSG\ngrizzling/M\ngrizzly/TRS\ngroan/GZSRDM\ngroaner/M\ngroat/SM\ngrocer/MS\ngrocery/MS\ngrog/MS\ngroggily\ngrogginess/SM\ngroggy/RPT\ngroin/MGSD\ngrok/S\ngrokked\ngrokking\ngrommet/GMDS\ngroofs\ngroom/GZSMRD\ngroomer/M\ngroomsman/M\ngroomsmen\ngroove/SRDGM\ngroover/M\ngroovy/TR\ngrope/SRDJGZ\ngroper/M\ngrosbeak/SM\ngrosgrain/MS\ngross/GTYSRDP\ngrossness/MS\ngrotesque/PSY\ngrotesqueness/MS\ngrotto/M\ngrottoes\ngrouch/GDS\ngrouchily\ngrouchiness/MS\ngrouchy/RPT\nground/JGZMDRS\ngroundbreaking/S\ngrounded/U\ngrounder/M\ngroundhog/SM\ngroundless/YP\ngroundlessness/M\ngroundnut/MS\ngroundsheet/M\ngroundskeepers\ngroundsman/M\ngroundswell/S\ngroundwater/S\ngroundwork/SM\ngroup/ZJSMRDG\ngrouped/A\ngrouper/M\ngroupie/MS\ngrouping/M\ngroups/A\ngrouse/GMZSRD\ngrouser/M\ngrout/GSMRD\ngrouter/M\ngrove/SRMZ\ngrovel/SDRGZ\ngroveler/M\ngrovelike\ngroveling/Y\ngrow/GZYRHS\ngrower/M\ngrowing/I\ngrowingly\ngrowl/RDGZS\ngrowler/M\ngrowling/Y\ngrowly/RP\ngrown/IA\ngrownup/MS\ngrows/A\ngrowth/IMA\ngrowths/IA\ngrub/MS\ngrubbed\ngrubber/SM\ngrubbily\ngrubbiness/SM\ngrubbing\ngrubby/RTP\ngrubstake/MSDG\ngrudge/GMSRDJ\ngrudger/M\ngrudging/Y\ngruel/MDGJS\ngrueling/Y\ngruesome/RYTP\ngruesomeness/SM\ngruff/PSGTYRD\ngruffness/MS\ngrumble/GZJDSR\ngrumbler/M\ngrumbling/Y\ngrump/MDGS\ngrumpily\ngrumpiness/MS\ngrumpy/TPR\ngrunge/S\ngrungy/RT\ngrunion/SM\ngrunt/SGRD\ngrunter/M\ngryphon's\ngs/A\ngt\nguacamole/MS\nguanine/MS\nguano/MS\nguarani/SM\nguarantee/RSDZM\nguaranteeing\nguarantor/SM\nguaranty/MSDG\nguard/RDSGZ\nguarded/UYP\nguardedness/UM\nguarder/M\nguardhouse/SM\nguardian/SM\nguardianship/MS\nguardrail/SM\nguardroom/SM\nguardsman/M\nguardsmen\nguava/SM\ngubernatorial\ngudgeon/M\nguernsey/S\nguerrilla/MS\nguess/BGZRSD\nguessable/U\nguessed/U\nguesser/M\nguesstimate/DSMG\nguesswork/MS\nguest/SGMD\nguff/SM\nguffaw/GSDM\nguidance/MS\nguide/GZSRD\nguidebook/SM\nguided/U\nguideline/SM\nguidepost/MS\nguider/M\nguild/SZMR\nguilder/M\nguildhall/SM\nguile/SDGM\nguileful\nguileless/YP\nguilelessness/MS\nguillemot/MS\nguillotine/SDGM\nguilt/SM\nguiltily\nguiltiness/MS\nguiltless/YP\nguiltlessness/M\nguilty/PTR\nguinea/SM\nguise's\nguise/SDEG\nguitar/SM\nguitarist/SM\ngulag/S\ngulch/MS\ngulden/MS\ngulf/DMGS\ngull/MDSG\ngullet/MS\ngulley's\ngullibility/MS\ngullible\ngully/SDMG\ngulp/RDGZS\ngum/MS\ngumbo/MS\ngumboil/MS\ngumboots\ngumdrop/SM\ngummed\ngumminess/M\ngumming/C\ngummy/RTP\ngumption/SM\ngumshoe/SDM\ngumshoeing\ngumtree/MS\ngun/MS\ngunboat/MS\ngunfight/SRMGZ\ngunfighter/M\ngunfire/SM\ngunflint/M\ngunfought\ngunk/SM\ngunky/RT\ngunman/M\ngunmen\ngunmetal/MS\ngunned\ngunnel's\ngunner/SM\ngunnery/MS\ngunning/M\ngunny/SM\ngunnysack/SM\ngunpoint/MS\ngunpowder/SM\ngunrunner/MS\ngunrunning/MS\ngunship/S\ngunshot/SM\ngunsling/GZR\ngunslinger/M\ngunsmith/M\ngunsmiths\ngunwale/MS\nguppy/SM\ngurgle/SDG\ngurney/S\nguru/MS\ngush/SRDGZ\ngusher/M\ngushy/TR\ngusset/MDSG\ngussy/GSD\ngust/MDGS\ngustatory\ngusted/E\ngustily\ngustiness/M\ngusting/E\ngusto/M\ngustoes\ngusts/E\ngusty/RPT\ngut/SM\ngutless/P\ngutlessness/S\nguts/R\ngutser/M\ngutsiness/M\ngutsy/PTR\ngutted\ngutter/GSDM\nguttering/M\nguttersnipe/M\ngutting\nguttural/SPY\ngutturalness/M\ngutty/RSMT\nguy/MDRZGS\nguzzle/GZRSD\nguzzler/M\ngym/MS\ngymkhana/SM\ngymnasia's\ngymnasium/SM\ngymnast/SM\ngymnastic/S\ngymnastically\ngymnastics/M\ngymnosperm/SM\ngynecologic\ngynecological/MS\ngynecologist/SM\ngynecology/MS\ngyp/S\ngypped\ngypper/S\ngypping\ngypsite\ngypster/S\ngypsum/MS\ngypsy/SDMG\ngyrate/XNGSD\ngyration/M\ngyrator/MS\ngyrfalcon/SM\ngyro/MS\ngyrocompass/M\ngyroscope/SM\ngyroscopic\ngyve/GDS\nh'm\nh's\nh/EMS\nha/H\nhabeas\nhaberdasher/SM\nhaberdashery/SM\nhabiliment/SM\nhabit's\nhabit/IBDGS\nhabitability/MS\nhabitable/P\nhabitableness/M\nhabitant/ISM\nhabitat/MS\nhabitation/MI\nhabitations\nhabitual/SYP\nhabitualness/SM\nhabituate/SDNGX\nhabituation/M\nhabitu/MS\nhacienda/MS\nhack/GZSDRBJ\nhacker/M\nhackle/RSDMG\nhackler/M\nhackney/SMDG\nhacksaw/SDMG\nhackwork/S\nhad/GD\nhaddock/MS\nhades\nhadj's\nhadji's\nhadn't\nhadron/MS\nhadst\nhaemoglobin's\nhaemophilia's\nhaemorrhage's\nhafnium/MS\nhaft/GSMD\nhag/SMN\nhaggard/SYP\nhaggardness/MS\nhagged\nhagging\nhaggis/SM\nhaggish\nhaggle/RSDZG\nhaggler/M\nhagiographer/SM\nhagiography/MS\nhahnium/S\nhaiku/M\nhail/SGMDR\nhailer/M\nhailstone/SM\nhailstorm/SM\nhair/SDM\nhairball/SM\nhairbreadth/M\nhairbreadths\nhairbrush/SM\nhaircare\nhaircloth/M\nhaircloths\nhaircut/MS\nhaircutting\nhairdo/SM\nhairdresser/SM\nhairdressing/SM\nhairdryer/S\nhairiness/MS\nhairless/P\nhairlessness/M\nhairlike\nhairline/SM\nhairnet/MS\nhairpiece/MS\nhairpin/MS\nhairsbreadth\nhairsbreadths\nhairsplitter/SM\nhairsplitting/MS\nhairspray\nhairspring/SM\nhairstyle/SMG\nhairstylist/S\nhairy/PTR\nhajj/M\nhajjes\nhajji/MS\nhake/MS\nhalal/S\nhalalled\nhalalling\nhalberd/SM\nhalcyon/S\nhale/ISRDG\nhaler/IM\nhalest\nhalf/PM\nhalfback/SM\nhalfbreed\nhalfhearted/PY\nhalfheartedness/MS\nhalfpence/S\nhalfpenny/MS\nhalfpennyworth\nhalftime/S\nhalftone/MS\nhalfway\nhalfword/MS\nhalibut/SM\nhalide/SM\nhalite/MS\nhalitoses\nhalitosis/M\nhall/SMR\nhallelujah\nhallelujahs\nhalliard's\nhallmark/SGMD\nhallo/GDS\nhalloo's\nhallow/UD\nhallowing\nhallows\nhallucinate/VNGSDX\nhallucination/M\nhallucinatory\nhallucinogen/SM\nhallucinogenic/S\nhallway/SM\nhalo/SDMG\nhalocarbon\nhalogen/SM\nhalogenated\nhalon\nhalt/GZJSMDR\nhalter/GDM\nhalting/Y\nhalve/GZDS\nhalves/M\nhalyard/MS\nham/SM\nhamburg/SZRM\nhamburger/M\nhamlet/MS\nhammed\nhammer/ZGSRDM\nhammerer/M\nhammerhead/SM\nhammering/M\nhammerless\nhammerlock/MS\nhammertoe/SM\nhamming\nhammock/MS\nhammy/RT\nhamper/GSD\nhampered/U\nhamster/MS\nhamstring/MGS\nhamstrung\nhand's\nhand/UDSG\nhandbag/MS\nhandbagged\nhandbagging\nhandball/SM\nhandbarrow/MS\nhandbasin\nhandbill/MS\nhandbook/SM\nhandbrake/M\nhandcar/SM\nhandcart/MS\nhandclasp/MS\nhandcraft/GMDS\nhandcuff/GSD\nhandcuffs/M\nhanded/PY\nhandedness/M\nhander/S\nhandful/SM\nhandgun/SM\nhandhold/M\nhandicap/SM\nhandicapped\nhandicapper/SM\nhandicapping\nhandicraft/SMR\nhandicraftsman/M\nhandicraftsmen\nhandily/U\nhandiness/SM\nhandiwork/MS\nhandkerchief/MS\nhandle/MZGRSD\nhandleable\nhandlebar/SM\nhandler/M\nhandless\nhandling/M\nhandmade\nhandmaid/NMSX\nhandmaiden/M\nhandout/SM\nhandover\nhandpick/GDS\nhandrail/SM\nhandsaw/SM\nhandset/SM\nhandshake/GMSR\nhandshaker/M\nhandshaking/M\nhandsome/RPTY\nhandsomely/U\nhandsomeness/MS\nhandspike/SM\nhandspring/SM\nhandstand/MS\nhandwork/SM\nhandwoven\nhandwrite/GSJ\nhandwriting/M\nhandwritten\nhandy/URT\nhandyman/M\nhandymen\nhang/GDRZBSJ\nhangar/SGDM\nhangdog/S\nhanged/A\nhanger/M\nhanging/M\nhangman/M\nhangmen\nhangnail/MS\nhangout/MS\nhangover/SM\nhangs/A\nhangup/S\nhank/GZDRMS\nhanker/GRDJ\nhankerer/M\nhankering/M\nhankie/SM\nhanky's\nhansom/MS\nhap/SMY\nhaphazard/SPY\nhaphazardness/SM\nhapless/YP\nhaplessness/MS\nhaploid/S\nhapped\nhappen/JDGS\nhappening/M\nhappenstance/SM\nhappily/U\nhappiness/UMS\nhapping\nhappy/UTPR\nharangue/GDRS\nharanguer/M\nharass/LSRDZG\nharasser/M\nharassment/SM\nharbinger/DMSG\nharbor/ZGRDMS\nharborer/M\nhard/YNRPJGXTS\nhardback/SM\nhardball/SM\nhardboard/SM\nhardboiled\nhardbound\nhardcore/MS\nhardcover/SM\nharden/ZGRD\nhardened/U\nhardener/M\nhardening/M\nhardhat/S\nhardheaded/YP\nhardheadedness/SM\nhardhearted/YP\nhardheartedness/SM\nhardihood/MS\nhardily\nhardiness/SM\nhardliner/S\nhardness/MS\nhardscrabble\nhardshell\nhardship/MS\nhardstand/S\nhardtack/MS\nhardtop/MS\nhardware/SM\nhardwire/DSG\nhardwood/MS\nhardworking\nhardy/PTRS\nhare/MGDS\nharebell/MS\nharebrained\nharelip/MS\nharelipped\nharem/SM\nhark/GDS\nharlequin/MS\nharlot/SM\nharlotry/MS\nharm/MDRGS\nharmed/U\nharmer/M\nharmful/PY\nharmfulness/MS\nharmless/YP\nharmlessness/SM\nharmonic/S\nharmonica/MS\nharmonically\nharmonics/M\nharmonious/IPY\nharmoniousness's/I\nharmoniousness/MS\nharmonium/MS\nharmonization's\nharmonization/A\nharmonizations\nharmonize/ZGSRD\nharmonized/U\nharmonizer/M\nharmonizes/UA\nharmony/EMS\nharness/DRSMG\nharnessed/U\nharnesser/M\nharnesses/U\nharp/MDRJGZS\nharper/M\nharping/M\nharpist/SM\nharpoon/SZGDRM\nharpooner/M\nharpsichord/SM\nharpsichordist/MS\nharpy/SM\nharridan/SM\nharrier/M\nharrow/RDMGS\nharrower/M\nharrumph/SDG\nharry/RSDGZ\nharsh/TRNYP\nharshen/GD\nharshness/SM\nhart/MS\nharvest/MDRZGS\nharvested/U\nharvester/M\nharvestman/M\nhas\nhash's\nhash/AGSD\nhasher/M\nhashing/M\nhashish/MS\nhasn't\nhasp/GMDS\nhassle/MGRSD\nhassock/MS\nhast/GXJDN\nhaste/MS\nhasten/GRD\nhastener/M\nhastily\nhastiness/MS\nhasty/RPT\nhat/MDRSZG\nhatch/RSDJG\nhatchback/SM\nhatcheck/S\nhatched/U\nhatcher/M\nhatchery/MS\nhatchet/MDSG\nhatching/M\nhatchway/MS\nhate/S\nhateful/YP\nhatefulness/MS\nhater/M\nhatless\nhatred/SM\nhatstands\nhatted\nhatter/SM\nhatting\nhauberk/SM\nhaughtily\nhaughtiness/SM\nhaughty/TPR\nhaul/SDRGZ\nhaulage/MS\nhauler/M\nhaunch/GMSD\nhaunt/JRDSZG\nhaunter/M\nhaunting/Y\nhauteur/MS\nhave/ZGSR\nhaven't\nhaven/DMGS\nhaver/G\nhaversack/SM\nhavoc/SM\nhavocked\nhavocking\nhaw/MDSG\nhawk/GZSDRM\nhawker/M\nhawking/M\nhawkish/P\nhawkishness/S\nhaws/RZ\nhawser/M\nhawthorn/MS\nhay/GSMDR\nhaycock/SM\nhayfield/MS\nhayloft/MS\nhaymow/MS\nhayrick/MS\nhayride/MS\nhayseed/MS\nhaystack/SM\nhaywain\nhaywire/MS\nhazard/MDGS\nhazardous/PY\nhazardousness/M\nhaze/DSRJMZG\nhazel/MS\nhazelnut/SM\nhazer/M\nhazily\nhaziness/MS\nhazing/M\nhazy/PTR\nhdqrs\nhe'd\nhe'll\nhe/VMZ\nhead/SJGZMDR\nheadache/MS\nheadband/SM\nheadboard/MS\nheadcount\nheaddress/MS\nheader/M\nheadfirst\nheadgear/SM\nheadhunt/ZGSRDMJ\nheadhunter/M\nheadhunting/M\nheadily\nheadiness/S\nheading/M\nheadlamp/S\nheadland/MS\nheadless/P\nheadlessness/M\nheadlight/MS\nheadline/DRSZMG\nheadliner/M\nheadlock/MS\nheadlong\nheadman/M\nheadmaster/MS\nheadmastership/M\nheadmen\nheadmistress/MS\nheadphone/SM\nheadpiece/SM\nheadpin/MS\nheadquarter/GDS\nheadrest/MS\nheadroom/SM\nheadscarf/M\nheadset/SM\nheadship/SM\nheadshrinker/MS\nheadsman/M\nheadsmen\nheadstall/SM\nheadstand/MS\nheadstock/M\nheadstone/MS\nheadstrong\nheadwaiter/SM\nheadwall/S\nheadwater/S\nheadway/MS\nheadwind/SM\nheadword/MS\nheady/PTR\nheal/DRHSGZ\nhealed/U\nhealer/M\nhealth/M\nhealthful/U\nhealthfully\nhealthfulness/SM\nhealthily/U\nhealthiness/MSU\nhealths\nhealthy/URPT\nheap/SMDG\nhear/ZTSRHJG\nheard/UA\nhearer/M\nhearing/AM\nhearken/SGD\nhears/SDAG\nhearsay/SM\nhearse/M\nheart/SMDNXG\nheartache/SM\nheartbeat/MS\nheartbreak/GMS\nheartbreaking/Y\nheartbroke\nheartbroken\nheartburn/SGM\nheartburning/M\nhearted/Y\nhearten/EGDS\nheartening/EY\nheartfelt\nhearth/M\nhearthrug\nhearths\nhearthstone/MS\nheartily\nheartiness/SM\nheartland/SM\nheartless/YP\nheartlessness/SM\nheartrending/Y\nheartsick/P\nheartsickness/MS\nheartstrings\nheartthrob/MS\nheartwarming\nheartwood/SM\nhearty/TRSP\nheat/SMDRGZBJ\nheated/UA\nheatedly\nheater/M\nheath/MRNZX\nheathen/M\nheathendom/SM\nheathenish/Y\nheathenism/MS\nheather/M\nheathery\nheathland\nheaths\nheatproof\nheats/A\nheatstroke/MS\nheatwave\nheave/DSRGZ\nheaven/SYM\nheavenliness/M\nheavenly/PTR\nheavenward/S\nheaver/M\nheaves/M\nheavily\nheaviness/MS\nheavy/TPRS\nheavyhearted\nheavyset\nheavyweight/SM\nhebephrenic\nhecatomb/M\nheck/S\nheckle/RSDZG\nheckler/M\nhectare/MS\nhectic/S\nhectically\nhectogram/MS\nhectometer/SM\nhector/SGD\nhedge/DSRGMZ\nhedgehog/MS\nhedgehop/S\nhedgehopped\nhedgehopping\nhedger/M\nhedgerow/SM\nhedging/Y\nhedonism/SM\nhedonist/MS\nhedonistic\nheed/SMGD\nheeded/U\nheedful/PY\nheedfulness/M\nheeding/U\nheedless/YP\nheedlessness/SM\nheehaw/DGS\nheel/SGZMDR\nheeler/M\nheeling/M\nheelless\nheft/GSD\nheftily\nheftiness/SM\nhefty/TRP\nhegemonic\nhegemony/MS\nhegira/S\nheifer/MS\nheight/SMNX\nheighten/GD\nheinous/PY\nheinousness/SM\nheir/SDMG\nheiress/MS\nheirloom/MS\nheist/GSMRD\nheister/M\nheld\nhelical/Y\nhelices/M\nhelicon/M\nhelicopter/GSMD\nheliocentric\nheliography/M\nheliosphere\nheliotrope/SM\nheliport/MS\nhelium/MS\nhelix/M\nhell/GSMDR\nhellbender/M\nhellbent\nhellcat/SM\nhellebore/SM\nheller/M\nhellfire/M\nhellhole/SM\nhellion/SM\nhellish/PY\nhellishness/SM\nhello/GMS\nhelluva\nhelm's\nhelm/U\nhelmed\nhelmet/GSMD\nhelming\nhelms\nhelmsman/M\nhelmsmen\nhelot/S\nhelp/GZSJDR\nhelper/M\nhelpful/UY\nhelpfulness/MS\nhelping/M\nhelpless/YP\nhelplessness/SM\nhelpline/S\nhelpmate/SM\nhelpmeet's\nhelve/GMDS\nhem/MS\nhematite/MS\nhematologic\nhematological\nhematologist/SM\nhematology/MS\nheme/MS\nhemisphere/MSD\nhemispheric\nhemispherical\nhemline/SM\nhemlock/MS\nhemmed\nhemmer/SM\nhemming\nhemoglobin/MS\nhemolytic\nhemophilia/SM\nhemophiliac/SM\nhemorrhage/GMDS\nhemorrhagic\nhemorrhoid/MS\nhemostat/SM\nhemp/MNS\nhemstitch/DSMG\nhen/MS\nhence/S\nhenceforth\nhenceforward\nhenchman/M\nhenchmen\nhenge/M\nhenna/MDSG\nhenning\nhenpeck/GSD\nhenry/M\nhep/S\nheparin/MS\nhepatic/S\nhepatitides\nhepatitis/M\nhepper\nheppest\nheptagon/SM\nheptagonal\nheptane/M\nheptathlon/S\nher\nherald/MDSG\nheralded/U\nheraldic\nheraldry/MS\nherb/MS\nherbaceous\nherbage/MS\nherbal/S\nherbalism\nherbalist/MS\nherbicidal\nherbicide/MS\nherbivore/SM\nherbivorous/Y\nherculean\nherd/MDRGZS\nherder/M\nherdsman/M\nherdsmen\nhere's\nhere/IS\nhereabout/S\nhereafter/S\nhereby\nhereditary\nheredity/MS\nherein\nhereinafter\nhereof\nhereon\nheres/M\nheresy/SM\nheretic/SM\nheretical\nhereto\nheretofore\nhereunder\nhereunto\nhereupon\nherewith\nheritable\nheritage/MS\nheritor/IM\nhermaphrodite/SM\nhermaphroditic\nhermeneutic/S\nhermeneutics/M\nhermetic/S\nhermetical/Y\nhermit/MS\nhermitage/SM\nhermitian\nhernia/MS\nhernial\nherniate/NGXDS\nhero/M\nheroes\nheroic/U\nheroically\nheroics\nheroin/MS\nheroine/SM\nheroism/SM\nheron/SM\nherpes/M\nherpetologist/SM\nherpetology/MS\nherring/SM\nherringbone/SDGM\nherself\nhertz/M\nhes\nhesitance/S\nhesitancy/SM\nhesitant/U\nhesitantly\nhesitate/XDRSNG\nhesitater/M\nhesitating/UY\nhesitation/M\nheterodox\nheterodoxy/MS\nheterodyne\nheterogamous\nheterogamy/M\nheterogeneity/SM\nheterogeneous/PY\nheterogeneousness/M\nheterosexual/YMS\nheterosexuality/SM\nheterostructure\nheterozygous\nheuristic/SM\nheuristically\nhew/DRZGS\nhewer/M\nhex/DSRG\nhexachloride/M\nhexadecimal/YS\nhexafluoride/M\nhexagon/SM\nhexagonal/Y\nhexagram/SM\nhexameter/SM\nhexer/M\nhey\nheyday/MS\nhf\nhgt\nhgwy\nhi/D\nhiatus/SM\nhibachi/MS\nhibernate/XGNSD\nhibernation/M\nhibernator/SM\nhibiscus/MS\nhiccup/MDGS\nhick/SM\nhickey/SM\nhickory/MS\nhid/ZDRGJ\nhidden/U\nhide/S\nhideaway/SM\nhidebound\nhideous/YP\nhideousness/SM\nhideout/MS\nhider/M\nhiding/M\nhie/S\nhieing\nhierarchal\nhierarchic\nhierarchical/Y\nhierarchy/SM\nhieratic\nhieroglyph\nhieroglyphic/S\nhieroglyphics/M\nhieroglyphs\nhifalutin\nhigh/PYRT\nhighball/GSDM\nhighborn\nhighboy/MS\nhighbrow/SM\nhighchair/SM\nhighfalutin\nhighhanded/PY\nhighhandedness/SM\nhighish\nhighland/ZSRM\nhighlight/GZRDMS\nhighness/MS\nhighpoint\nhighroad/MS\nhighs\nhight\nhightail/DGS\nhighway/MS\nhighwayman/M\nhighwaymen\nhijack/JZRDGS\nhijacker/M\nhike/ZGDSR\nhiker/M\nhilarious/YP\nhilariousness/MS\nhilarity/MS\nhill/GSMDR\nhillbilly/MS\nhiller/M\nhilliness/SM\nhillman\nhillmen\nhillock/SM\nhillside/SM\nhilltop/MS\nhillwalking\nhilly/TRP\nhilt/MDGS\nhim/S\nhimself\nhind/RSZ\nhinder/GRD\nhindered/U\nhinderer/M\nhindmost\nhindquarter/SM\nhindrance/SM\nhindsight/SM\nhinge's\nhinge/UDSG\nhinger\nhint/GZMDRS\nhinter/M\nhinterland/MS\nhip/PSM\nhipbone/SM\nhipness/S\nhipped\nhipper\nhippest\nhippie/MTRS\nhipping/M\nhippo/MS\nhippodrome/MS\nhippopotamus/SM\nhippy's\nhipster/MS\nhiragana\nhire/AGSD\nhireling/SM\nhirer/SM\nhiring/S\nhirsute/P\nhirsuteness/MS\nhis\nhiss/DSRMJG\nhisser/M\nhissing/M\nhist/SDG\nhistamine/SM\nhistidine/SM\nhistochemic\nhistochemical\nhistochemistry/M\nhistogram/MS\nhistological\nhistologist/MS\nhistology/SM\nhistorian/MS\nhistoric\nhistorical/PY\nhistoricalness/M\nhistoricism/M\nhistoricist/M\nhistoricity/MS\nhistoriographer/SM\nhistoriography/MS\nhistory/MS\nhistrionic/S\nhistrionically\nhistrionics/M\nhit/MS\nhitch/UGSD\nhitcher/MS\nhitchhike/RSDGZ\nhither\nhitherto\nhitless\nhittable\nhitter/SM\nhitting\nhive/MGDS\nho/DRYZ\nhoar/M\nhoard/RDJZSGM\nhoarder/M\nhoarding/M\nhoarfrost/SM\nhoariness/MS\nhoarse/RTYP\nhoarseness/SM\nhoary/TPR\nhoax/GZMDSR\nhoaxer/M\nhob/SM\nhobbed\nhobbing\nhobbit\nhobble/ZSRDG\nhobbler/M\nhobby/SM\nhobbyhorse/SM\nhobbyist/SM\nhobgoblin/MS\nhobnail/GDMS\nhobnob/S\nhobnobbed\nhobnobbing\nhobo/SDMG\nhoc\nhock/GDRMS\nhocker/M\nhockey/SM\nhockshop/SM\nhod/SM\nhodge/MS\nhodgepodge/SM\nhoe/SM\nhoecake/SM\nhoedown/MS\nhoeing\nhoer/M\nhog/SM\nhogan/SM\nhogback/MS\nhogged\nhogger\nhogging\nhoggish/Y\nhogshead/SM\nhogtie/SD\nhogtying\nhogwash/SM\nhoist/GRDS\nhoister/M\nhoke/DSG\nhokey/PRT\nhokier\nhokiest\nhokum/MS\nhold/NRBSJGZ\nholdall/MS\nholder/M\nholding's\nholding/IS\nholdout/SM\nholdover/SM\nholdup/MS\nhole/MGDS\nholey\nholiday/GRDMS\nholidaymaker/S\nholier/U\nholiness/MSU\nholistic\nholistically\nhollandaise\nholler/GDS\nhollow/RDYTGSP\nhollowness/MS\nhollowware/M\nholly/SM\nhollyhock/MS\nholmium/MS\nholocaust/MS\nhologram/SM\nholograph/GMD\nholographic\nholographs\nholography/MS\nholster/MDSG\nholy/SRTP\nholystone/MS\nhomage/MGSRD\nhomager/M\nhombre/SM\nhomburg/SM\nhome/DSRMYZG\nhomebody/MS\nhomebound\nhomeboy/S\nhomebuilder/S\nhomebuilding\nhomebuilt\nhomecoming/MS\nhomegrown\nhomeland/SM\nhomeless/P\nhomelessness/SM\nhomelike\nhomeliness/SM\nhomely/RPT\nhomemade\nhomemake/JRZG\nhomemaker/M\nhomemaking/M\nhomeomorph/M\nhomeomorphic\nhomeomorphism/MS\nhomeopath\nhomeopathic\nhomeopaths\nhomeopathy/MS\nhomeostases\nhomeostasis/M\nhomeostatic\nhomeowner/S\nhomeownership\nhomepage\nhomer/GDM\nhomerists\nhomeroom/MS\nhomeschooling/S\nhomesick/P\nhomesickness/MS\nhomespun/S\nhomestead/GZSRDM\nhomesteader/M\nhomestretch/SM\nhometown/SM\nhomeward\nhomework/ZSMR\nhomeworker/M\nhomey/PS\nhomeyness/MS\nhomicidal/Y\nhomicide/SM\nhomier\nhomiest\nhomiletic/S\nhomily/SM\nhominess's\nhoming/M\nhominid/MS\nhominy/SM\nhomo/SM\nhomogamy/M\nhomogenate/MS\nhomogeneity/ISM\nhomogeneous/PY\nhomogenization/MS\nhomogenize/DRSGZ\nhomogenizer/M\nhomograph/M\nhomographs\nhomological\nhomologous\nhomologue/M\nhomology/MS\nhomomorphic\nhomomorphism/SM\nhomonym/SM\nhomophobia/S\nhomophobic\nhomophone/MS\nhomopolymers\nhomosexual/YMS\nhomosexuality/SM\nhomotopy\nhomozygous/Y\nhon/MDRSZTG\nhoncho/DSG\nhone/SM\nhonest/RYT\nhonestly/E\nhonesty/ESM\nhoney/GSMD\nhoneybee/SM\nhoneycomb/SDMG\nhoneydew/SM\nhoneylocust\nhoneymoon/RDMGZS\nhoneymooner/M\nhoneysuckle/MS\nhong/M\nhonk/GZSDRM\nhonker/M\nhonky/SM\nhonor's\nhonor/ERDBZGS\nhonorable/PSM\nhonorableness/SM\nhonorables/U\nhonorablies/U\nhonorably/UE\nhonorarily\nhonorarium/SM\nhonorary/S\nhonored/U\nhonoree/S\nhonorer/EM\nhonorific/S\nhonors/A\nhooch/MS\nhood/MDSG\nhooded/P\nhoodedness/M\nhoodlum/SM\nhoodoo/DMGS\nhoodwink/SRDG\nhoodwinker/M\nhooey/SM\nhoof/DRMSG\nhoofer/M\nhoofmark/S\nhook/GZDRMS\nhookah/M\nhookahs\nhooked/P\nhookedness/M\nhooker/M\nhookey's\nhooks/U\nhookup/SM\nhookworm/MS\nhooky/SRMT\nhooligan/SM\nhooliganism/SM\nhoop/MDRSG\nhooper/M\nhoopla/SM\nhooray/SMDG\nhoosegow/MS\nhoot/MDRSGZ\nhootch's\nhootenanny/SM\nhooter/M\nhooves/M\nhop/SMDRG\nhope/SM\nhoped/U\nhopeful/SPY\nhopefulness/MS\nhopeless/YP\nhopelessness/SM\nhoper/M\nhopped\nhopper/MS\nhopping/M\nhoppled\nhopples\nhopscotch/MDSG\nhorde/DSGM\nhorehound/MS\nhorizon/MS\nhorizontal/YS\nhormonal/Y\nhormone/MS\nhorn/GDRMS\nhornbeam/M\nhornblende/MS\nhorned/P\nhornedness/M\nhornet/MS\nhorniness/M\nhornless\nhornlike\nhornpipe/MS\nhorny/TRP\nhorologic\nhorological\nhorologist/MS\nhorology/MS\nhoroscope/MS\nhorrendous/Y\nhorrible/SP\nhorribleness/SM\nhorribly\nhorrid/PY\nhorridness/M\nhorrific\nhorrifically\nhorrify/DSG\nhorrifying/Y\nhorror/MS\nhors/DSGX\nhorse's\nhorse/UGDS\nhorseback/MS\nhorsedom\nhorseflesh/M\nhorsefly/MS\nhorsehair/SM\nhorsehide/SM\nhorselaugh/M\nhorselaughs\nhorseless\nhorselike\nhorsely\nhorseman/M\nhorsemanship/MS\nhorsemen\nhorseplay/SMR\nhorseplayer/M\nhorsepower/SM\nhorseradish/SM\nhorseshoe/MRSD\nhorseshoeing\nhorseshoer/M\nhorsetail/SM\nhorsewhip/SM\nhorsewhipped\nhorsewhipping\nhorsewoman/M\nhorsewomen\nhorsey\nhorsier\nhorsiest\nhorsing/M\nhortatory\nhorticultural\nhorticulture/SM\nhorticulturist/SM\nhos/GDS\nhosanna/SDG\nhose/M\nhosepipe\nhosier/MS\nhosiery/SM\nhosp\nhospice/MS\nhospitable/I\nhospitably/I\nhospital/MS\nhospitality's/I\nhospitality/MS\nhospitalization/MS\nhospitalize/GSD\nhost/MYDGS\nhostage/MS\nhostel/SZGMRD\nhosteler/M\nhostelry/MS\nhostess/MDSG\nhostile/YS\nhostility/SM\nhostler/MS\nhot/PSY\nhotbed/MS\nhotblooded\nhotbox/MS\nhotcake/S\nhotchpotch/M\nhotel/MS\nhotelier/MS\nhotelman/M\nhotfoot/DGS\nhothead/DMS\nhotheaded/PY\nhotheadedness/SM\nhothouse/MGDS\nhotness/MS\nhotplate/SM\nhotpot/M\nhotrod\nhotshot/S\nhotted\nhotter\nhottest\nhotting\nhough/M\nhound/MRDSG\nhounder/M\nhounding/M\nhour/YMS\nhourglass/MS\nhouri/MS\nhourly/S\nhouse's\nhouse/ASDG\nhouseboat/SM\nhousebound\nhouseboy/SM\nhousebreak/JSRZG\nhousebreaker/M\nhousebreaking/M\nhousebroke\nhousebroken\nhousebuilding\nhouseclean/JDSG\nhousecleaning/M\nhousecoat/MS\nhousefly/MS\nhouseful/SM\nhousehold/ZRMS\nhouseholder/M\nhousehusband/S\nhousekeep/JRGZ\nhousekeeper/M\nhousekeeping/M\nhouselights\nhousemaid/MS\nhouseman/M\nhousemen\nhousemother/MS\nhousemoving\nhouseparent/SM\nhouseplant/S\nhouser\nhousetop/MS\nhousewares\nhousewarming/MS\nhousewife/YM\nhousewifeliness/M\nhousewifely/P\nhousewives\nhousework/ZSMR\nhouseworker/M\nhousing/MS\nhove/ZR\nhovel/GSMD\nhover/GRD\nhovercraft/M\nhoverer/M\nhow/SM\nhowbeit\nhowdah/M\nhowdahs\nhowdy/GSD\nhowever\nhowitzer/MS\nhowl/GZSMDR\nhowler/M\nhowsoever\nhoy/M\nhoyden/DMGS\nhoydenish\nhp\nhr\nhrs\nht\nhuarache/SM\nhub/MS\nhubba\nhubbub/SM\nhubby/SM\nhubcap/SM\nhubris/SM\nhuckleberry/SM\nhuckster/SGMD\nhuddle/RSDMG\nhuddler/M\nhue/MDS\nhuff/SGDM\nhuffily\nhuffiness/SM\nhuffy/TRP\nhug/RTS\nhuge/YP\nhugeness/MS\nhugged\nhugger\nhugging/S\nhuh\nhuhs\nhula/MDSG\nhulk/GDMS\nhull/MDRGZS\nhullabaloo/SM\nhuller/M\nhulling/M\nhullo/GSDM\nhum/S\nhuman/IPY\nhumane/IY\nhumaneness/SM\nhumaner\nhumanest\nhumanism/SM\nhumanist/SM\nhumanistic\nhumanitarian/S\nhumanitarianism/SM\nhumanity/ISM\nhumanization/CSM\nhumanize/RSDZG\nhumanized/C\nhumanizer/M\nhumanizes/IAC\nhumanizing/C\nhumankind/M\nhumanness/IM\nhumannesses\nhumanoid/S\nhumans\nhumble/TZGPRSDJ\nhumbleness/SM\nhumbly\nhumbug/MS\nhumbugged\nhumbugging\nhumdinger/MS\nhumdrum/S\nhumeral/S\nhumeri\nhumerus/M\nhumid/Y\nhumidification/MC\nhumidifier/CM\nhumidify/RSDCXGNZ\nhumidistat/M\nhumidity/MS\nhumidor/MS\nhumiliate/SDXNG\nhumiliating/Y\nhumiliation/M\nhumility/MS\nhummed\nhummer/SM\nhumming\nhummingbird/SM\nhummock/MDSG\nhummocky\nhummus/S\nhumongous\nhumor/RDMZGS\nhumored/U\nhumorist/MS\nhumorless/PY\nhumorlessness/MS\nhumorous/YP\nhumorousness/MS\nhump/GSMD\nhumpback/SMD\nhumph/DG\nhumphs\nhumus/SM\nhunch/GMSD\nhunchback/DSM\nhundred/SHRM\nhundredfold/S\nhundredths\nhundredweight/SM\nhung/A\nhunger/SDMG\nhungover\nhungrily\nhungriness/SM\nhungry/RTP\nhunk/ZRMS\nhunker/DG\nhunky/RST\nhunt/GZJDRS\nhunter/M\nhunting/M\nhuntress/MS\nhuntsman/M\nhuntsmen\nhurdle/JMZGRSD\nhurdler/M\nhurl/DRGZJS\nhurler/M\nhurling/M\nhurray/SDG\nhurricane/MS\nhurried/UY\nhurriedness/M\nhurry/RSDG\nhurt/U\nhurter/M\nhurtful/PY\nhurtfulness/MS\nhurting/Y\nhurtle/SDG\nhurts\nhusband/GSDRYM\nhusbander/M\nhusbandman/M\nhusbandmen\nhusbandry/SM\nhush/DSG\nhusk/SGZDRM\nhusker/M\nhuskily\nhuskiness/MS\nhusking/M\nhusky/RSPT\nhussar/MS\nhussy/SM\nhustings/M\nhustle/RSDZG\nhustler/M\nhut/MS\nhutch/MSDG\nhutted\nhutting\nhuzzah/GD\nhuzzahs\nhwy\nhyacinth/M\nhyacinths\nhyaena's\nhybrid/MS\nhybridism/SM\nhybridization/S\nhybridize/GSD\nhydra/MS\nhydrangea/SM\nhydrant/SM\nhydrate's\nhydrate/CSDNGX\nhydration/MC\nhydraulic/S\nhydraulically\nhydraulicked\nhydraulicking\nhydraulics/M\nhydrazine/M\nhydride/MS\nhydro/SM\nhydrocarbon/SM\nhydrocephali\nhydrocephalus/MS\nhydrochemistry\nhydrochloric\nhydrochloride/M\nhydrodynamic/S\nhydrodynamical\nhydrodynamics/M\nhydroelectric\nhydroelectrically\nhydroelectricity/SM\nhydrofluoric\nhydrofoil/MS\nhydrogen/MS\nhydrogenate's\nhydrogenate/CDSGN\nhydrogenation/MC\nhydrogenations\nhydrogenous\nhydrological/Y\nhydrologist/MS\nhydrology/SM\nhydrolysis/M\nhydrolyze/GSD\nhydrolyzed/U\nhydromagnetic\nhydromechanics/M\nhydrometer/SM\nhydrometry/MS\nhydrophilic\nhydrophobia/SM\nhydrophobic\nhydrophone/SM\nhydroplane/DSGM\nhydroponic/S\nhydroponics/M\nhydrosphere/MS\nhydrostatic/S\nhydrostatics/M\nhydrotherapy/SM\nhydrothermal/Y\nhydrous\nhydroxide/MS\nhydroxy\nhydroxyl/SM\nhydroxylate/N\nhydroxyzine/M\nhyena/MS\nhygiene/MS\nhygienic/S\nhygienically\nhygienics/M\nhygienist/MS\nhygrometer/SM\nhygroscopic\nhying\nhymen/MS\nhymeneal/S\nhymn/GSDM\nhymnal/SM\nhymnbook/S\nhype/MZGDSR\nhyperactive/S\nhyperactivity/SM\nhyperbola/MS\nhyperbole/MS\nhyperbolic\nhyperbolically\nhyperboloid/SM\nhyperboloidal\nhypercellularity\nhypercritical/Y\nhypercube/MS\nhyperemia/M\nhyperemic\nhyperfine\nhypergamous/Y\nhypergamy/M\nhyperglycemia/MS\nhyperinflation\nhypermarket/SM\nhypermedia/S\nhyperplane/SM\nhyperplasia/M\nhypersensitive/P\nhypersensitiveness/MS\nhypersensitivity/MS\nhypersonic\nhyperspace/M\nhypersphere/M\nhypertension/MS\nhypertensive/S\nhypertext/SM\nhyperthyroid\nhyperthyroidism/MS\nhypertrophy/MSDG\nhypervelocity\nhyperventilate/XSDGN\nhyperventilation/M\nhyphen/DMGS\nhyphenate/NGXSD\nhyphenated/U\nhyphenation/M\nhypnoses\nhypnosis/M\nhypnotherapy/SM\nhypnotic/S\nhypnotically\nhypnotism/MS\nhypnotist/SM\nhypnotize/SDG\nhypo/DMSG\nhypoactive\nhypoallergenic\nhypocellularity\nhypochondria/MS\nhypochondriac/SM\nhypocrisy/SM\nhypocrite/MS\nhypocritical/Y\nhypodermic/S\nhypoglycemia/SM\nhypoglycemic/S\nhypophyseal\nhypophysectomized\nhypotenuse/MS\nhypothalami\nhypothalamic\nhypothalamically\nhypothalamus/M\nhypothermia/SM\nhypotheses\nhypothesis/M\nhypothesize/ZGRSD\nhypothesizer/M\nhypothetic\nhypothetical/Y\nhypothyroid\nhypothyroidism/SM\nhypoxia/M\nhyssop/MS\nhysterectomy/MS\nhysteresis/M\nhysteria/SM\nhysteric/SM\nhysterical/YU\ni\ni's\niamb/MS\niambi\niambic/S\niambus/SM\nibex/MS\nibid\nibidem\nibis/SM\nibuprofen/S\nice's\nice/GDSC\niceberg/SM\niceboat/MS\nicebound\nicebox/MS\nicebreaker/SM\nicecap/SM\niceman/M\nicemen\nicepack\nicepick/S\nichneumon/M\nichthyologist/MS\nichthyology/MS\nicicle/SM\nicily\niciness/SM\nicing/MS\nicky/RT\nicon/MS\niconic\niconoclasm/MS\niconoclast/MS\niconoclastic\niconography/MS\nicosahedra\nicosahedral\nicosahedron/M\nictus/SM\nicy/RPT\nid/MY\nidea/SM\nideal/MYS\nidealism/MS\nidealist/MS\nidealistic\nidealistically\nidealization/MS\nidealize/GDRSZ\nidealized/U\nidealizer/M\nidealogical\nideate/SN\nideation/M\nidem\nidempotent/S\nidentical/YP\nidenticalness/M\nidentifiability\nidentifiable/U\nidentifiably\nidentification/M\nidentified/U\nidentifier/M\nidentify/XZNSRDG\nidentity/SM\nideogram/MS\nideograph/M\nideographic\nideographs\nideological/Y\nideologist/SM\nideologue/S\nideology/SM\nides\nidiocy/MS\nidiolect/M\nidiom/MS\nidiomatic/P\nidiomatically\nidiopathic\nidiosyncrasy/SM\nidiosyncratic\nidiosyncratically\nidiot/MS\nidiotic\nidiotically\nidle/PZTGDSR\nidleness/MS\nidler/M\nidol/MS\nidolater/MS\nidolatress/S\nidolatrous\nidolatry/SM\nidolization/SM\nidolize/ZGDRS\nidolized/U\nidolizer/M\nids\nidyll/MS\nidyllic\nidyllically\nif\niffiness/S\niffy/TPR\nifs\nigloo/MS\nigneous\nignitable\nignite/ASDG\nigniter/M\nignition/MS\nignoble/P\nignobleness/M\nignobly\nignominious/Y\nignominy/MS\nignoramus/SM\nignorance/MS\nignorant/SPY\nignorantness/M\nignore/SRDGB\nignorer/M\niguana/MS\nii\niii\nikon's\nilea\nileitides\nileitis/M\nileum/M\nilia\niliac\nilium/M\nilk/MS\nill/PS\nillegal/YS\nillegality/MS\nillegibility/MS\nillegible\nillegibly\nillegitimacy/SM\nillegitimate/SDGY\nilliberal/Y\nilliberality/SM\nillicit/YP\nillicitness/MS\nillimitable/P\nillimitableness/M\nilliquid\nilliteracy/MS\nilliterate/PSY\nilliterateness/M\nillness/MS\nillogic/M\nillogical/PY\nillogicality/SM\nillogicalness/M\nillume/DG\nilluminate/XSDVNG\nilluminating/U\nilluminatingly\nillumination/M\nillumine/BGSD\nillus/V\nillusion's\nillusion/ES\nillusionary\nillusionist/MS\nillusive/PY\nillusiveness/M\nillusoriness/M\nillusory/P\nillustrate/VGNSDX\nillustrated/U\nillustration/M\nillustrative/Y\nillustrator/SM\nillustrious/PY\nillustriousness/SM\nilly\nimage/DSGM\nimagery/MS\nimaginable/U\nimaginableness\nimaginably/U\nimaginariness/M\nimaginary/PS\nimagination/MS\nimaginative/UY\nimaginativeness/M\nimagine/RSDJBG\nimagined/U\nimaginer/M\nimago/M\nimagoes\nimam/MS\nimbalance/SDM\nimbecile/YMS\nimbecilic\nimbecility/MS\nimbibe/ZRSDG\nimbiber/M\nimbrication/SM\nimbroglio/MS\nimbruing\nimbue/GDS\nimitable/I\nimitate/SDVNGX\nimitation/M\nimitative/YP\nimitativeness/MS\nimitator/SM\nimmaculate/YP\nimmaculateness/SM\nimmanence/S\nimmanency/MS\nimmanent/Y\nimmaterial/PY\nimmateriality/MS\nimmaterialness/MS\nimmature/SPY\nimmatureness/M\nimmaturity/MS\nimmeasurable/P\nimmeasurableness/M\nimmeasurably\nimmediacy/MS\nimmediate/YP\nimmediateness/SM\nimmemorial/Y\nimmense/PRTY\nimmenseness/M\nimmensity/MS\nimmerse/RSDXNG\nimmersible\nimmersion/M\nimmigrant/SM\nimmigrate/NGSDX\nimmigration/M\nimminence/SM\nimminent/YP\nimminentness/M\nimmobile\nimmobility/MS\nimmobilization/MS\nimmobilize/DSRG\nimmoderate/NYP\nimmoderateness/M\nimmoderation/M\nimmodest/Y\nimmodesty/SM\nimmolate/SDNGX\nimmolation/M\nimmoral/Y\nimmorality/MS\nimmortal/SY\nimmortality/SM\nimmortalize/GDS\nimmortalized/U\nimmovability/SM\nimmovable/PS\nimmovableness/M\nimmovably\nimmune/S\nimmunity/SM\nimmunization/MS\nimmunize/GSD\nimmunoassay/M\nimmunodeficiency/S\nimmunodeficient\nimmunologic\nimmunological/Y\nimmunologist/SM\nimmunology/MS\nimmure/GSD\nimmutability/MS\nimmutable/P\nimmutableness/M\nimmutably\nimp/SGMDRY\nimpact/VGMRDS\nimpaction/SM\nimpactor/SM\nimpair/LGRDS\nimpaired/U\nimpairer/M\nimpairment/SM\nimpala/MS\nimpale/GLRSD\nimpalement/SM\nimpaler/M\nimpalpable\nimpalpably\nimpanel/DGS\nimpart/GDS\nimpartation/M\nimpartial/Y\nimpartiality/SM\nimpassable/P\nimpassableness/M\nimpassably\nimpasse/SXBMVN\nimpassibility/SM\nimpassible\nimpassibly\nimpassion/DG\nimpassioned/U\nimpassive/YP\nimpassiveness/MS\nimpassivity/MS\nimpasto/SM\nimpatience/SM\nimpatiens/M\nimpatient/Y\nimpeach/DRSZGLB\nimpeachable/U\nimpeacher/M\nimpeachment/MS\nimpeccability/SM\nimpeccable/S\nimpeccably\nimpecunious/PY\nimpecuniousness/MS\nimped/GRD\nimpedance/MS\nimpede/S\nimpeded/U\nimpeder/M\nimpediment/SM\nimpedimenta\nimpel/S\nimpelled\nimpeller/MS\nimpelling\nimpend/DGS\nimpenetrability/MS\nimpenetrable/P\nimpenetrableness/M\nimpenetrably\nimpenitence/MS\nimpenitent/YS\nimperative/PSY\nimperativeness/M\nimperceivable\nimperceptibility/MS\nimperceptible\nimperceptibly\nimperceptive\nimperf\nimperfect/YSVP\nimperfectability\nimperfection/MS\nimperfectness/SM\nimperial/YS\nimperialism/MS\nimperialist/SM\nimperialistic\nimperialistically\nimperil/GSLD\nimperilment/SM\nimperious/YP\nimperiousness/MS\nimperishable/SP\nimperishableness/M\nimperishably\nimpermanence/MS\nimpermanent/Y\nimpermeability/SM\nimpermeable/P\nimpermeableness/M\nimpermeably\nimpermissible\nimpersonal/Y\nimpersonality/M\nimpersonalized\nimpersonate/XGNDS\nimpersonation/M\nimpersonator/SM\nimpertinence/SM\nimpertinent/YS\nimperturbability/SM\nimperturbable\nimperturbably\nimpervious/PY\nimperviousness/M\nimpetigo/MS\nimpetuosity/MS\nimpetuous/YP\nimpetuousness/MS\nimpetus/MS\nimpiety/MS\nimping/GD\nimpinge/LS\nimpingement/MS\nimpious/PY\nimpiousness/SM\nimpish/YP\nimpishness/MS\nimplacability/SM\nimplacable/P\nimplacableness/M\nimplacably\nimplant/BGSDR\nimplantation/SM\nimplanter/M\nimplausibility/MS\nimplausible\nimplausibly\nimplement/SMRDGZB\nimplementability\nimplementable/U\nimplementation's\nimplementation/A\nimplementations\nimplemented/AU\nimplementer/M\nimplementing/A\nimplementor/MS\nimplicant/SM\nimplicate/VGSD\nimplication/M\nimplicative/PY\nimplicit/YP\nimplicitness/SM\nimplied/Y\nimplode/GSD\nimplore/GSD\nimploring/Y\nimplosion/SM\nimplosive/S\nimply/GNSDX\nimpolite/YP\nimpoliteness/MS\nimpolitic/PY\nimpoliticness/M\nimponderable/PS\nimponderableness/M\nimport/SZGBRD\nimportance/SM\nimportant/Y\nimportation/MS\nimporter/M\nimporting/A\nimportunate/PYGDS\nimportunateness/M\nimportune/SRDZYG\nimportuner/M\nimportunity/SM\nimposable\nimpose/ASDG\nimposer/SM\nimposing/U\nimposingly\nimposition/SM\nimpossibility/SM\nimpossible/PS\nimpossibleness/M\nimpossibly\nimpost/SGMD\nimposter's\nimpostor/SM\nimposture/SM\nimpotence/MS\nimpotency/S\nimpotent/SY\nimpound/GDS\nimpoundments\nimpoverish/LGDRS\nimpoverisher/M\nimpoverishment/SM\nimpracticable/P\nimpracticableness/M\nimpracticably\nimpractical/PY\nimpracticality/SM\nimpracticalness/M\nimprecate/NGXSD\nimprecation/M\nimprecise/PYXN\nimpreciseness/MS\nimprecision/M\nimpregnability/MS\nimpregnable/P\nimpregnableness/M\nimpregnably\nimpregnate/DSXNG\nimpregnation/M\nimpresario/SM\nimpress/DRSGVL\nimpressed/U\nimpresser/M\nimpressibility/MS\nimpressible\nimpression/BMS\nimpressionability/SM\nimpressionable/P\nimpressionableness/M\nimpressionism/SM\nimpressionist/MS\nimpressionistic\nimpressive/YP\nimpressiveness/MS\nimpressment/M\nimprimatur/SM\nimprint/SZDRGM\nimprinter/M\nimprinting/M\nimprison/GLDS\nimprisonment/MS\nimprobability/MS\nimprobable/P\nimprobableness/M\nimprobably\nimpromptu/S\nimproper/PY\nimproperness/M\nimpropitious\nimpropriety/SM\nimprove/SRDGBL\nimproved/U\nimprovement/MS\nimprover/M\nimprovidence/SM\nimprovident/Y\nimprovisation/MS\nimprovisational\nimprovisatory\nimprovise/RSDZG\nimproviser/M\nimprudence/SM\nimprudent/Y\nimpudence/MS\nimpudent/Y\nimpugn/SRDZGB\nimpugner/M\nimpulse/XMVGNSD\nimpulsion/M\nimpulsive/YP\nimpulsiveness/MS\nimpunity/SM\nimpure/RPTY\nimpureness/M\nimpurity/MS\nimputation/SM\nimpute/SDBG\nin/AS\ninaction\ninactive\ninadequate/S\ninadvertence/MS\ninadvertent/Y\ninalienability/MS\ninalienably\ninalterable/P\ninalterableness/M\ninamorata/MS\ninane/SRPYT\ninanimate/P\ninanimateness/S\ninanity/MS\ninappeasable\ninappropriate/P\ninarticulate/P\ninasmuch\ninaugural/S\ninaugurate/XSDNG\ninauguration/M\ninauthenticity\ninbound/G\ninbred/S\ninbreed/JG\ninc/T\nincalculableness/M\nincalculably\nincandescence/SM\nincandescent/YS\nincant\nincantation/SM\nincantatory\nincapable/S\nincapacitate/GNSD\nincapacitation/M\nincarcerate/XGNDS\nincarceration/M\nincarnadine/GDS\nincarnate/AGSDNX\nincarnation/AM\nincendiary/S\nincense/MGDS\nincentive/ESM\nincentively\nincept/DGVS\ninception/MS\ninceptive/Y\ninceptor/M\nincessant/Y\nincest/SM\nincestuous/PY\nincestuousness/MS\ninch/GMDS\ninchoate/DSG\ninchworm/MS\nincidence/MS\nincident/SM\nincidental/YS\nincinerate/XNGSD\nincineration/M\nincinerator/SM\nincipience/SM\nincipiency/M\nincipient/Y\nincise/SDVGNX\nincision/M\nincisive/YP\nincisiveness/MS\nincisor/MS\nincite/RZL\nincitement/MS\ninciter/M\nincl\ninclination/ESM\nincline/EGSD\nincliner/M\ninclining/M\ninclude/GDS\ninclusion/MS\ninclusive/PY\ninclusiveness/MS\nincognito/S\nincoherency/M\nincome/M\nincommode/DG\nincommunicado\nincomparable\nincompetent/MS\nincomplete/P\ninconceivability/MS\ninconceivable/P\ninconceivableness/M\nincondensable\nincongruousness/S\ninconsiderable/P\ninconsiderableness/M\ninconsistence\ninconsolable/P\ninconsolableness/M\ninconsolably\nincontestability/SM\nincontestably\nincontrovertibly\ninconvenience/DG\ninconvertibility\ninconvertible\nincorporable\nincorporate/GASDXN\nincorporated/UE\nincorrect/P\nincorrigibility/MS\nincorrigible/SP\nincorrigibleness/M\nincorrigibly\nincorruptible/S\nincorruptibly\nincrease/JB\nincreaser/M\nincreasing/Y\nincredible/P\nincredibleness/M\nincrement/DMGS\nincremental/Y\nincrementation\nincriminate/XNGSD\nincrimination/M\nincriminatory\nincrustation/SM\nincubate/XNGVDS\nincubation/M\nincubator/MS\nincubus/MS\ninculcate/SDGNX\ninculcation/M\ninculpate/SDG\nincumbency/MS\nincumbent/S\nincunabula\nincunabulum\nincurable/S\nincurious\nincursion/SM\nind\nindebted/P\nindebtedness/SM\nindefatigable/P\nindefatigableness/M\nindefatigably\nindefeasible\nindefeasibly\nindefinable/PS\nindefinableness/M\nindefinite/S\nindelible\nindelibly\nindemnification/M\nindemnify/NXSDG\nindemnity/SM\nindent/R\nindentation/SM\nindented/U\nindenter/M\nindention/SM\nindenture/DG\nindescribable/PS\nindescribableness/M\nindescribably\nindestructible/P\nindestructibleness/M\nindestructibly\nindeterminably\nindeterminacy/MS\nindeterminism\nindex/MRDZGB\nindexation/S\nindexer/M\nindicant/MS\nindicate/DSNGVX\nindication/M\nindicative/SY\nindicator/MS\nindices's\nindict/SGLBDR\nindicter/M\nindictment/SM\nindifference\nindigence/MS\nindigenous/YP\nindigenousness/M\nindigent/SY\nindigestible/S\nindignant/Y\nindignation/MS\nindigo/SM\nindirect/PG\nindiscreet/P\nindiscriminate/PY\nindiscriminateness/M\nindispensability/MS\nindispensable/SP\nindispensableness/M\nindispensably\nindisputable/P\nindisputableness/M\nindissoluble/P\nindissolubleness/M\nindissolubly\nindistinguishable/P\nindistinguishableness/M\nindite/SDG\nindium/SM\nindividual/YMS\nindividualism/MS\nindividualist/MS\nindividualistic\nindividualistically\nindividuality/MS\nindividualization/SM\nindividualize/DRSGZ\nindividualized/U\nindividualizer/M\nindividualizes/U\nindividualizing/Y\nindividuate/DSXGN\nindividuation/M\nindivisible/SP\nindivisibleness/M\nindivisibly\nindoctrinate/GNXSD\nindoctrination/M\nindoctrinator/SM\nindolence/SM\nindolent/Y\nindomitable/P\nindomitableness/M\nindomitably\nindoor\nindubitable/P\nindubitableness/M\nindubitably\ninduce/ZGLSRD\ninducement/MS\ninducer/M\ninducible\ninduct/GV\ninductance/MS\ninductee/SM\ninduction/SM\ninductive/PY\ninductiveness/M\ninductor/MS\nindulge/GDRS\nindulgence/SDGM\nindulgent/Y\nindulger/M\nindustrial/SY\nindustrialism/MS\nindustrialist/MS\nindustrialization/MS\nindustrialize/SDG\nindustrialized/U\nindustrious/YP\nindustriousness/SM\nindustry/SM\ninebriate/NGSDX\ninebriation/M\ninedible\nineducable\nineffability/MS\nineffable/P\nineffableness/M\nineffably\ninelastic\nineligibly\nineluctable\nineluctably\ninept/YP\nineptitude/SM\nineptness/MS\ninequivalent\ninerrant\ninert/SPY\ninertia/SM\ninertial/Y\ninertness/MS\ninescapably\ninestimably\ninevitability/MS\ninevitable/P\ninevitableness/M\ninevitably\ninexact/P\ninexhaustible/P\ninexhaustibleness/M\ninexhaustibly\ninexorability/M\ninexorable/P\ninexorableness/M\ninexorably\ninexpedience/M\ninexplicable/P\ninexplicableness/M\ninexplicably\ninexplicit\ninexpressibility/M\ninexpressible/PS\ninexpressibleness/M\ninextricably\ninf/ZT\ninfamous\ninfamy/SM\ninfancy/M\ninfant/MS\ninfanticide/MS\ninfantile\ninfantry/SM\ninfantryman/M\ninfantrymen\ninfarct/SM\ninfarction/SM\ninfatuate/XNGSD\ninfatuation/M\ninfauna\ninfect/ESGDA\ninfected/U\ninfecter\ninfection/EASM\ninfectious/PY\ninfectiousness/MS\ninfective\ninfer/B\ninference/GMSR\ninferential/Y\ninferior/SMY\ninferiority/MS\ninfernal/Y\ninferno/MS\ninferred\ninferring\ninfertile\ninfest/GSDR\ninfestation/MS\ninfester/M\ninfidel/SM\ninfighting/M\ninfill/MG\ninfiltrate/V\ninfiltrator/MS\ninfinite/V\ninfinitesimal/SY\ninfinitival\ninfinitive/YMS\ninfinitude/MS\ninfinitum\ninfinity/SM\ninfirmary/SM\ninfirmity/SM\ninfix/M\ninflammable/P\ninflammableness/M\ninflammation/MS\ninflammatory\ninflatable/MS\ninflate/NGBDRSX\ninflater/M\ninflation/ESM\ninflationary\ninflect/GVDS\ninflection/SM\ninflectional/Y\ninflexible/P\ninflexibleness/M\ninflexion/SM\ninflict/DRSGV\ninflicter/M\ninfliction/SM\ninflow/M\ninfluence/SRDGM\ninfluenced/U\ninfluencer/M\ninfluent\ninfluential/SY\ninfluenza/MS\ninfo/SM\ninfomercial/S\ninformatics\ninformation/ES\ninformational\ninformative/UY\ninformativeness/S\ninformatory\ninformed/U\ninformer/M\ninfotainment/S\ninfra\ninfrared/SM\ninfrasonic\ninfrastructural\ninfrastructure/MS\ninfrequence/S\ninfringe/LR\ninfringement/SM\ninfringer/M\ninfuriate/GNYSD\ninfuriating/Y\ninfuriation/M\ninfuse/RZ\ninfuser/M\ninfusible/P\ninfusibleness/M\ningenious/YP\ningeniousness/MS\ningenuity/SM\ningenuous/EY\ningenuousness/MS\ningest/DGVS\ningestible\ningestion/SM\ninglenook/MS\ningoing\ningot/SMDG\ningrained/Y\ningrate/M\ningratiate/DSGNX\ningratiating/Y\ningratiation/M\ningredient/SM\ningress/MS\ningression/M\ningrown/P\ninguinal\ningnue/S\ninhabit/R\ninhabitable/U\ninhabitance\ninhabited/U\ninhabiter/M\ninhalant/S\ninhalation/SM\ninhalator/SM\ninhale/Z\ninhere/DG\ninherent/Y\ninherit/BDSG\ninheritable/P\ninheritableness/M\ninheritance/EMS\ninherited/E\ninheriting/E\ninheritor/S\ninheritress/MS\ninheritrix/MS\ninherits/E\ninhibit/DVGS\ninhibited/U\ninhibiter's\ninhibition/MS\ninhibitor/MS\ninhibitory\ninhomogeneous\ninhospitable/P\ninhospitableness/M\ninhospitality\ninimical/Y\ninimitable/P\ninimitableness/M\ninimitably\ninion\niniquitous/PY\niniquitousness/M\niniquity/MS\ninitial/GSPRDY\ninitialer/M\ninitialization's\ninitialization/A\ninitializations\ninitialize/ASDG\ninitialized/U\ninitializer/S\ninitiate/UD\ninitiates\ninitiating\ninitiation/SM\ninitiative/SM\ninitiator/MS\ninitiatory\ninject/GVSDB\ninjectable/U\ninjection/MS\ninjector/SM\ninjunctive\ninjure/SRDZG\ninjured/U\ninjurer/M\ninjurious/YP\ninjuriousness/M\nink/ZDRJ\ninkblot/SM\ninker/M\ninkiness/MS\ninkling/SM\ninkstand/SM\ninkwell/SM\ninky/TP\ninland\ninlander/M\ninlay/RG\ninletting\ninly/G\ninmost\ninn/ZGDRSJ\ninnards\ninnate/YP\ninnateness/SM\ninner/Y\ninnermost/S\ninnersole/S\ninnerspring\ninnervate/GNSDX\ninnervation/M\ninning/M\ninnkeeper/MS\ninnocence/SM\ninnocent/SYRT\ninnocuous/PY\ninnocuousness/MS\ninnovate/SDVNGX\ninnovation/M\ninnovative/P\ninnovator/MS\ninnovatory\ninnuendo/MDGS\ninnumerability/M\ninnumerable/P\ninnumerableness/M\ninnumerably\ninnumerate\ninoculate/ASDG\ninoculation/MS\ninoculative\ninoffensive/P\ninopportune/P\ninopportuneness/M\ninordinate/PY\ninordinateness/M\ninorganic\ninpatient\ninput/MRDG\ninquire/ZR\ninquirer/M\ninquiring/Y\ninquiry/MS\ninquisition/MS\ninquisitional\ninquisitive/YP\ninquisitiveness/MS\ninquisitor/MS\ninquisitorial/Y\ninrush/M\nins\ninsalubrious\ninsanitary\ninsatiability/MS\ninsatiable/P\ninsatiableness/M\ninsatiably\ninscribe/Z\ninscription/SM\ninscrutability/SM\ninscrutable/P\ninscrutableness/SM\ninscrutably\ninseam\ninsecticidal\ninsecticide/MS\ninsectivore/SM\ninsectivorous\ninsecure/P\ninsecureness/M\ninseminate/NGXSD\ninsemination/M\ninsensate/P\ninsensateness/M\ninsensible/P\ninsentient\ninseparable/S\ninsert/ADSG\ninserter/M\ninsertion/AMS\ninsetting\ninshore\ninside/Z\ninsider/M\ninsidious/YP\ninsidiousness/MS\ninsightful/Y\ninsigne's\ninsignia/SM\ninsignificant\ninsinuate/VNGXSD\ninsinuating/Y\ninsinuation/M\ninsinuator/SM\ninsipid/Y\ninsipidity/MS\ninsist/SGD\ninsistence/SM\ninsistent/Y\ninsisting/Y\ninsociable\ninsofar\ninsole/M\ninsolence/SM\ninsolent/YS\ninsoluble/P\ninsolubleness/M\ninsolubly\ninsomnia/MS\ninsomniac/S\ninsomuch\ninsouciance/SM\ninsouciant/Y\ninspect/AGSD\ninspection/SM\ninspective\ninspector/SM\ninspectorate/MS\ninspiration/MS\ninspirational/Y\ninspire/R\ninspired/U\ninspirer/M\ninspiring/U\ninspirit/DG\ninst/B\ninstall/ADRSG\ninstallable\ninstallation/SM\ninstaller/MS\ninstallment/MS\ninstance/GD\ninstant/SRYMP\ninstantaneous/PY\ninstantaneousness/M\ninstantiate/SDXNG\ninstantiated/U\ninstantiation/M\ninstate/AGSD\ninstead\ninstigate/XSDVGN\ninstigation/M\ninstigator/SM\ninstillation/SM\ninstinct/VMS\ninstinctive/Y\ninstinctual\ninstitute/ZXVGNSRD\ninstituter/M\ninstitutes/M\ninstitution/AM\ninstitutional/Y\ninstitutionalism/M\ninstitutionalist/M\ninstitutionalization/SM\ninstitutionalize/GDS\ninstitutor's\ninstr\ninstruct/DSVG\ninstructed/U\ninstruction/MS\ninstructional\ninstructive/PY\ninstructiveness/M\ninstructor/MS\ninstrument/GMDS\ninstrumental/SY\ninstrumentalist/MS\ninstrumentality/SM\ninstrumentation/SM\ninsubordinate\ninsubstantial\ninsufferable\ninsufferably\ninsular/YS\ninsularity/MS\ninsulate/DSXNG\ninsulated/U\ninsulation/M\ninsulator/MS\ninsulin/MS\ninsult/DRSG\ninsulter/M\ninsulting/Y\ninsuperable\ninsuperably\ninsupportable/P\ninsupportableness/M\ninsurance's/A\ninsurance/MS\ninsure/BZGS\ninsured/S\ninsurer/M\ninsurgence/SM\ninsurgency/MS\ninsurgent/MS\ninsurmountably\ninsurrection/SM\ninsurrectionist/SM\nint/ZR\nintact/P\nintactness/M\nintaglio/GMDS\nintake/M\nintangible/M\ninteger/MS\nintegrability/M\nintegrable\nintegral/SYM\nintegrand/MS\nintegrate/AGNXEDS\nintegration/EMA\nintegrative/E\nintegrator/MS\nintegrity/SM\nintegument/SM\nintellect/MVS\nintellective/Y\nintellectual/YPS\nintellectualism/MS\nintellectuality/M\nintellectualize/GSD\nintellectualness/M\nintelligence/MSR\nintelligencer/M\nintelligent/UY\nintelligentsia/MS\nintelligibilities\nintelligibility/UM\nintelligible/PU\nintelligibleness/MU\nintelligibly/U\nintemperate/P\nintendant/MS\nintended/SYP\nintendedness/M\nintender/M\nintensification/M\nintensifier/M\nintensify/GXNZRSD\nintensional/Y\nintensive/PSY\nintensiveness/MS\nintent/YP\nintention/SDM\nintentional/UY\nintentionality/M\nintentness/SM\ninter/ESTL\ninteract/VGDS\ninteraction/MS\ninteractive/PY\ninteractivity\ninteraxial\ninterbank\ninterbred\ninterbreed/GS\nintercalate/GNVDS\nintercalation/M\nintercase\nintercaste\nintercede/SRDG\ninterceder/M\nintercensal\nintercept/DGS\ninterception/MS\ninterceptor/MS\nintercession/MS\nintercessor/SM\nintercessory\ninterchange/DSRGJ\ninterchangeability/M\ninterchangeable/P\ninterchangeableness/M\ninterchangeably\ninterchanger/M\nintercity\ninterclass\nintercohort\nintercollegiate\nintercom/SM\nintercommunicate/SDXNG\nintercommunication/M\ninterconnect/GDS\ninterconnected/P\ninterconnectedness/M\ninterconnection/SM\ninterconnectivity\nintercontinental\ninterconversion/M\nintercorrelated\nintercourse/SM\ninterdenominational\ninterdepartmental/Y\ninterdependence/MS\ninterdependency/SM\ninterdependent/Y\ninterdict/MDVGS\ninterdiction/MS\ninterdisciplinary\ninterest/GEMDS\ninterested/UYE\ninteresting/YP\ninterestingly/U\ninterestingness/M\ninterface/SRDGM\ninterfacing/M\ninterfaith\ninterfere/SRDG\ninterference/MS\ninterferer/M\ninterfering/Y\ninterferometer/SM\ninterferometric\ninterferometry/M\ninterferon/MS\ninterfile/GSD\nintergalactic\nintergeneration/M\nintergenerational\ninterglacial\nintergovernmental\nintergroup\ninterim/S\ninterindex\ninterindustry\ninterior/SMY\ninterj\ninterject/GDS\ninterjection/MS\ninterjectional\ninterlace/GSD\ninterlard/SGD\ninterlayer/G\ninterleave/SDG\ninterleukin/S\ninterlibrary\ninterline/JGSD\ninterlinear/S\ninterlingua/M\ninterlingual\ninterlining/M\ninterlink/GDS\ninterlisp/M\ninterlobular\ninterlock/RDSG\ninterlocker/M\ninterlocutor/MS\ninterlocutory\ninterlope/GZSRD\ninterloper/M\ninterlude/MSDG\nintermarriage/MS\nintermarry/GDS\nintermediary/MS\nintermediate/YMNGSDP\nintermediateness/M\nintermediation/M\ninterment/SME\nintermeshed\nintermetrics\nintermezzi\nintermezzo/SM\ninterminably\nintermingle/DSG\nintermission/MS\nintermittent/Y\nintermix/GSRD\nintermodule\nintermolecular/Y\nintern/L\ninternal/SY\ninternalization/SM\ninternalize/GDS\ninternational/YS\ninternationalism/SM\ninternationalist/SM\ninternationality/M\ninternationalization/MS\ninternationalize/DSG\ninterne's\ninternecine\ninternee/SM\ninternetwork\ninternist/SM\ninternment/SM\ninternship/MS\ninternuclear\ninterocular\ninteroffice\ninteroperability\ninterpenetrates\ninterpersonal/Y\ninterplanetary\ninterplay/GSMD\ninterpol\ninterpolate/XGNVBDS\ninterpolation/M\ninterpose/GSRD\ninterposer/M\ninterposition/MS\ninterpret/AGSD\ninterpretable/U\ninterpretation/MSA\ninterpretative/Y\ninterpreted/U\ninterpreter/SM\ninterpretive/Y\ninterpretor/S\ninterprocess\ninterprocessor\ninterquartile\ninterracial\ninterred/E\ninterregional\ninterregnum/MS\ninterrelate/GNDSX\ninterrelated/PY\ninterrelatedness/M\ninterrelation/M\ninterrelationship/SM\ninterring/E\ninterrogate/DSXGNV\ninterrogation/M\ninterrogative/SY\ninterrogator/SM\ninterrogatory/S\ninterrupt/VGZRDS\ninterrupted/U\ninterrupter/M\ninterruptibility\ninterruptible\ninterruption/MS\ninterscholastic\nintersect/GDS\nintersection/MS\nintersession/MS\ninterspecies\nintersperse/GNDSX\ninterspersion/M\ninterstage\ninterstate/S\ninterstellar\ninterstice/SM\ninterstitial/SY\nintersurvey\nintertask\nintertwine/GSD\ninterurban/S\ninterval/MS\nintervene/GSRD\nintervener/M\nintervenor/M\nintervention/MS\ninterventionism/MS\ninterventionist/S\ninterview/AMD\ninterviewed/U\ninterviewee/SM\ninterviewer/SM\ninterviewing\ninterviews\nintervocalic\ninterweave/GS\ninterwove\ninterwoven\nintestacy/SM\nintestinal/Y\nintestine/SM\ninti\nintifada\nintimacy/SM\nintimal\nintimate/XYNGPDRS\nintimateness/M\nintimater/M\nintimation/M\nintimidate/SDXNG\nintimidating/Y\nintimidation/M\ninto\nintolerable/P\nintolerableness/M\nintolerant/PS\nintonate/NX\nintonation/M\nintoxicant/MS\nintoxicate/DSGNX\nintoxicated/Y\nintoxication/M\nintra\nintracellular\nintracity\nintraclass\nintracohort\nintractability/M\nintractable/P\nintractableness/M\nintradepartmental\nintrafamily\nintragenerational\nintraindustry\nintraline\nintrametropolitan\nintramural/Y\nintramuscular/Y\nintranasal\nintransigence/MS\nintransigent/YS\nintransitive/S\nintraoffice\nintraprocess\nintrapulmonary\nintraregional\nintrasectoral\nintrastate\nintratissue\nintrauterine\nintravenous/YS\nintrepid/YP\nintrepidity/SM\nintrepidness/M\nintricacy/SM\nintricate/PY\nintricateness/M\nintrigue/DRSZG\nintriguer/M\nintriguing/Y\nintrinsic/S\nintrinsically\nintro/S\nintroduce/ADSG\nintroducer/M\nintroduction/ASM\nintroductory\nintroit/SM\nintroject/SD\nintrospect/SGVD\nintrospection/MS\nintrospective/YP\nintrospectiveness/M\nintroversion/SM\nintrovert/SMDG\nintrude/ZGDSR\nintruder/M\nintrusion/SM\nintrusive/SYP\nintrusiveness/MS\nintubate/NGDS\nintubation/M\nintuit/GVDSB\nintuitionist/M\nintuitive/YP\nintuitiveness/MS\ninundate/SXNG\ninundation/M\ninure/GDS\ninvade/ZSRDG\ninvader/M\ninvalid/GSDM\ninvalidism/MS\ninvariable/P\ninvariant/M\ninvasion/SM\ninvasive/P\ninvective/PSMY\ninvectiveness/M\ninveigh/DRG\ninveigher/M\ninveighs\ninveigle/DRSZG\ninveigler/M\ninvent/ADGS\ninvented/U\ninvention/ASM\ninventive/YP\ninventiveness/MS\ninventor/MS\ninventory/SDMG\ninverse/YV\ninvert/ZSGDR\ninverter/M\ninvertible\ninvest/ADSLG\ninvestigate/XDSNGV\ninvestigation/MA\ninvestigator/MS\ninvestigatory\ninvestiture/SM\ninvestment's/A\ninvestment/ESA\ninvestor/SM\ninveteracy/MS\ninveterate/Y\ninviability\ninvidious/YP\ninvidiousness/MS\ninvigilate/GD\ninvigilator/SM\ninvigorate/ANGSD\ninvigorating/Y\ninvigoration/AM\ninvigorations\ninvincibility/SM\ninvincible/P\ninvincibleness/M\ninvincibly\ninviolability/MS\ninviolably\ninviolate/YP\ninviolateness/M\ninviscid\ninvisible/S\ninvisibleness/M\ninvitation/MS\ninvitational/S\ninvite/SRDG\ninvited/U\ninvitee/S\ninviter/M\ninviting/Y\ninvocable\ninvocate\ninvoke/GSRDBZ\ninvoked/A\ninvoker/M\ninvokes/A\ninvoluntariness/S\ninvoluntary/P\ninvolute/XYN\ninvolution/M\ninvolutorial\ninvolve/GDSRL\ninvolved/U\ninvolvedly\ninvolvement/SM\ninvolver/M\ninvulnerability/M\ninvulnerableness/M\ninward/PY\ninwardness/M\nioctl\niodate/MGND\niodation/M\niodide/MS\niodinate/DNG\niodine/MS\niodize/GSD\nion's/I\nion/SMU\nionic/S\nionization's\nionization/SU\nionize/GNSRDJXZ\nionized/UC\nionizer's\nionizer/US\nionizes/U\nionizing/U\nionosphere/SM\nionospheric\niota/SM\nipecac/MS\nipso\nirascibility/SM\nirascible\nirascibly\nirate/RPYT\nirateness/S\nire/MGDS\nireful\nirenic/S\nirides/M\niridescence/SM\niridescent/Y\niridium/MS\nirids\niris/GDSM\nirk/GDS\nirksome/YP\nirksomeness/SM\niron/DRMPSGJ\nironclad/S\nironer/M\nironic\nironical/YP\nironicalness/M\nironing/M\nironmonger/M\nironmongery/M\nironside/MS\nironstone/MS\nironware/SM\nironwood/SM\nironwork/MRS\nironworker/M\nirony/SM\nirradiate/XSDVNG\nirradiation/M\nirrational/YSP\nirrationality/MS\nirrationalness/M\nirreclaimable\nirreconcilability/MS\nirreconcilable/PS\nirreconcilableness/M\nirreconcilably\nirrecoverable/P\nirrecoverableness/M\nirrecoverably\nirredeemable/S\nirredeemably\nirredentism/M\nirredentist/M\nirreducibility/M\nirreducible\nirreducibly\nirreflexive\nirrefutable\nirrefutably\nirregardless\nirregular/YS\nirregularity/SM\nirrelevance/SM\nirrelevancy/MS\nirrelevant/Y\nirreligious\nirremediable/P\nirremediableness/M\nirremediably\nirremovable\nirreparable/P\nirreparableness/M\nirreparably\nirreplaceable/P\nirrepressible\nirrepressibly\nirreproachable/P\nirreproachableness/M\nirreproachably\nirreproducibility\nirreproducible\nirresistibility/M\nirresistible/P\nirresistibleness/M\nirresistibly\nirresolute/PNXY\nirresoluteness/SM\nirresolution/M\nirresolvable\nirrespective/Y\nirresponsibility/SM\nirresponsible/PS\nirresponsibleness/M\nirresponsibly\nirretrievable\nirretrievably\nirreverence/MS\nirreverent/Y\nirreversible\nirreversibly\nirrevocable/P\nirrevocableness/M\nirrevocably\nirrigable\nirrigate/DSXNG\nirrigation/M\nirritability/MS\nirritable/P\nirritableness/M\nirritably\nirritant/S\nirritate/DSXNGV\nirritated/Y\nirritating/Y\nirritation/M\nirrupt/GVSD\nirruption/SM\nis\nisinglass/MS\nisl/GD\nisland/GZMRDS\nislander/M\nisle/MS\nislet/SM\nism/MCS\nisn't\nisobar/MS\nisobaric\nisochronal/Y\nisochronous/Y\nisocline/M\nisocyanate/M\nisodine\nisolate/SDXNG\nisolation/M\nisolationism/SM\nisolationist/SM\nisolationistic\nisolator/MS\nisomer/SM\nisomeric\nisomerism/SM\nisometric/S\nisometrically\nisometrics/M\nisomorph/M\nisomorphic\nisomorphically\nisomorphism/MS\nisoperimetrical\nisopleth/M\nisopleths\nisosceles\nisostatic\nisotherm/MS\nisothermal/Y\nisotonic\nisotope/SM\nisotopic\nisotropic\nisotropically\nisotropy/M\nispell/M\nissuable\nissuance/MS\nissuant\nissue/GMZDSR\nissued/A\nissuer/AMS\nissues/A\nissuing/A\nisthmian/S\nisthmus/SM\nit'd\nit'll\nit/MUS\nital\nitalic/S\nitalicization/MS\nitalicize/GSD\nitalicized/U\nitch/GMDS\nitchiness/MS\nitchy/RTP\nitem/MDSG\nitemization/SM\nitemize/GZDRS\nitemized/U\nitemizer/M\nitemizes/A\niterate/ASDXVGN\niteration/M\niterative/YA\niterator/MS\nitinerant/SY\nitinerary/MS\nits\nitself\niv/M\nivory/SM\nivy/MDS\nix\nj's\nj/F\njab/SM\njabbed\njabber/JRDSZG\njabberer/M\njabbing\njabot/MS\njacaranda/MS\njack/GDRMS\njackal/SM\njackass/SM\njackboot/DMS\njackdaw/SM\njacket/GSMD\njacketed/U\njackhammer/MDGS\njackknife/MGSD\njackknives\njackpot/MS\njackrabbit/DGS\njackstraw/MS\njacquard/MS\njacuzzi\njade/MGDS\njaded/PY\njadedness/SM\njadeite/SM\njag/S\njagged/RYTP\njaggedness/SM\njaggers\njagging\njaguar/MS\njail/GZSMDR\njailbird/MS\njailbreak/SM\njailer/M\njalapeo/S\njalopy/SM\njalousie/MS\njam/SM\njamb/DMGS\njambalaya/MS\njamboree/MS\njammed/U\njamming/U\njangle/RSDGZ\njangler/M\njangly\njanissary/MS\njanitor/SM\njanitorial\njapan/SM\njapanned\njapanner\njapanning\njape/DSMG\njar/MS\njardinire/MS\njarful/S\njargon/SGDM\njarred\njarring/SY\njasmine/MS\njasper/MS\njato/SM\njaundice/DSMG\njaundiced/U\njaunt/MDGS\njauntily\njauntiness/MS\njaunty/SRTP\njavelin/SDMG\njaw/SMDG\njawbone/SDMG\njawbreaker/SM\njawline\njay/SM\njaybird/SM\njaywalk/JSRDZG\njaywalker/M\njazz/MGDS\njazziness/M\njazzmen\njazzy/PTR\njct\njealous/PY\njealousness/M\njealousy/MS\njean/MS\njeep/GZSMD\njeer/SJDRMG\njeerer/M\njeering/Y\njeez\njehad's\njejuna\njejune/PY\njejuneness/M\njejunum/M\njell/GSD\njello's\njelly/SDMG\njellybean/SM\njellyfish/MS\njellying/M\njellylike\njellyroll/S\njemmy/M\njennet/SM\njenny/SM\njeopard\njeopardize/GSD\njeopardy/MS\njeremiad/SM\njerk/GSDRJ\njerker/M\njerkily\njerkin/SM\njerkiness/SM\njerkwater/S\njerky/RSTP\njerry/M\njerrybuilt\njersey/MS\njess/M\njessamine's\njest/DRSGZM\njester/M\njesting/Y\njet/MS\njetliner/MS\njetport/SM\njetsam/MS\njetted/M\njetting/M\njettison/DSG\njetty/RSDGMT\njewel/GZMRDS\njeweler/M\njewelery/S\njewellery's\njewelry/MS\njg/M\njib/MDSG\njibbed\njibbing\njibe/S\njiff/S\njiffy/SM\njig/MS\njigged\njigger/SDMG\njigging/M\njiggle/SDG\njiggly/TR\njigsaw/GSDM\njihad/SM\njilt/DRGS\njilter/M\njimmy/GSDM\njimsonweed/S\njingle/RSDG\njingler/M\njingly/TR\njingo/M\njingoism/SM\njingoist/SM\njingoistic\njinn/MS\njinni's\njinrikisha/SM\njinx/GMDS\njitney/MS\njitter/S\njitterbug/SM\njitterbugged\njitterbugger\njitterbugging\njittery/TR\njiujitsu's\njive/MGDS\njob/SM\njobbed\njobber/MS\njobbery/M\njobbing/M\njobholder/SM\njobless/P\njoblessness/MS\njock/GDMS\njockey/SGMD\njockstrap/MS\njocose/YP\njocoseness/MS\njocosity/SM\njocular/Y\njocularity/SM\njocund/Y\njocundity/SM\njodhpurs\njoey/M\njog/S\njogged\njogger/SM\njogging/S\njoggle/SRDG\njoggler/M\njohn/SM\njohnny/SM\njohnnycake/SM\njoin/ADGFS\njoined/U\njoiner/FSM\njoinery/MS\njoint's\njoint/EGDYPS\njointed/EYP\njointedness/ME\njointer/M\njointly/F\njointures\njoist/GMDS\njoke/MZDSRG\njoker/M\njokey\njokier\njokiest\njokily\njoking/Y\njollification/MS\njollily\njolliness/SM\njollity/MS\njolly/TSRDGP\njolt/DRGZS\njolter/M\njonquil/MS\njosh/DSRGZ\njosher/M\njoss/M\njostle/SDG\njot/S\njotted\njotter/SM\njotting/SM\njoule/SM\njounce/SDG\njouncy/RT\njournal/GSDM\njournalese/MS\njournalism/SM\njournalist/SM\njournalistic\njournalize/DRSGZ\njournalized/U\njournalizer/M\njourney/DRMZSGJ\njourneyer/M\njourneyman/M\njourneymen\njoust/ZSMRDG\njouster/M\njovial/Y\njoviality/SM\njowl/SMD\njowly/TR\njoy/MDSG\njoyful/PY\njoyfuller\njoyfullest\njoyfulness/SM\njoyless/PY\njoylessness/MS\njoyous/YP\njoyousness/MS\njoyridden\njoyride/SRZMGJ\njoyrode\njoystick/S\njubilant/Y\njubilate/XNGDS\njubilation/M\njubilee/SM\njuddered\njuddering\njudge's\njudge/AGDS\njudger/M\njudgeship/SM\njudgment/MS\njudgmental/Y\njudicable\njudicatory/S\njudicature/MS\njudicial/Y\njudiciary/S\njudicious/IYP\njudiciousness/SMI\njudo/MS\njug/MS\njugate/F\njugful/SM\njugged\njuggernaut/SM\njugging\njuggle/RSDGZ\njuggler/M\njugglery/MS\njugular/S\njuice/GMZDSR\njuicer/M\njuicily\njuiciness/MS\njuicy/TRP\njujitsu/MS\njuju/M\njujube/SM\njujutsu's\njuke/GS\njukebox/SM\njulep/SM\njulienne/GSD\njumble/GSD\njumbo/MS\njump/GZDRS\njumper/M\njumpily\njumpiness/MS\njumpsuit/S\njumpy/PTR\njun\njunco/MS\njunction/IMESF\njuncture/SFM\njungle/SDM\njunior/MS\njuniority/M\njuniper/SM\njunk/GZDRMS\njunkerdom\njunket/SMDG\njunketeer/SGDM\njunkie/RSMT\njunkyard/MS\njunta/MS\njuridic\njuridical/Y\njuried\njurisdiction/SM\njurisdictional/Y\njurisprudence/SM\njurisprudent\njurisprudential/Y\njurist/MS\njuristic\njuror/MS\njury/IMS\njurying\njuryman/M\njurymen\njurywoman/M\njurywomen\njust/UPY\njusted\njuster/M\njustest\njustice/MIS\njusticiable\njustifiability/M\njustifiable/U\njustifiably/U\njustification/M\njustified/UA\njustifier/M\njustify/GDRSXZN\njusting\njustness's/U\njustness/MS\njusts\njut/S\njute/SM\njutted\njutting\njuvenile/SM\njuxtapose/SDG\njuxtaposition/SM\nk's/IE\nk/FGEIS\nkHz/M\nkW\nkWh\nkabob/SM\nkaboom\nkabuki/SM\nkaddish/S\nkaffeeklatch\nkaffeeklatsch/S\nkaftan's\nkaiser/MS\nkale/MS\nkaleidescope\nkaleidoscope/SM\nkaleidoscopic\nkaleidoscopically\nkamikaze/SM\nkangaroo/SGMD\nkaolin/MS\nkaolinite/M\nkapok/SM\nkappa/MS\nkaput/M\nkarakul/MS\nkaraoke/S\nkarat/SM\nkarate/MS\nkarma/SM\nkarmic\nkart/MS\nkatakana\nkatydid/SM\nkayak/SGDM\nkayo/DMSG\nkazoo/SM\nkc/M\nkcal/M\nkebab/SM\nkeel/GSMDR\nkeelhaul/SGD\nkeen/GTSPYDR\nkeener/M\nkeening/M\nkeenness/MS\nkeep/GZJSR\nkeeper/M\nkeeping/M\nkeepsake/SM\nkeg/MS\nkegged\nkegging\nkelp/GZMDS\nkelvin/MS\nken/MS\nkenned\nkennel/GSMD\nkenning\nkeno/M\nkepi/SM\nkept\nkeratin/MS\nkerbside\nkerchief/MDSG\nkerned\nkernel/GSMD\nkerning\nkerosene/MS\nkestrel/SM\nketch/MS\nketchup/SM\nketone/M\nketosis/M\nkettle/SM\nkettledrum/SM\nkettleful\nkey/SGMD\nkeyboard/RDMZGS\nkeyboardist/S\nkeyclick/SM\nkeyhole/MS\nkeynote/SRDZMG\nkeynoter/M\nkeypad/MS\nkeypunch/ZGRSD\nkeypuncher/M\nkeyring\nkeystone/SM\nkeystroke/SDMG\nkeyword/SM\nkg\nkhaki/SM\nkhan/MS\nkibble/GMSD\nkibbutz/M\nkibbutzim\nkibitz/GRSDZ\nkibitzer/M\nkibosh/GMSD\nkick/GZDRS\nkickback/SM\nkickball/MS\nkicker/M\nkickoff/SM\nkickstand/MS\nkicky/RT\nkid/MS\nkidded\nkidder/SM\nkiddie/SD\nkidding/YM\nkiddish\nkiddo/SM\nkiddy's\nkiddying\nkidless\nkidnap/MSJ\nkidnaper's\nkidnaping's\nkidnapped\nkidnapper/SM\nkidnapping/S\nkidney/MS\nkidskin/SM\nkielbasa/SM\nkielbasi\nkier/I\nkill/BJGZSDR\nkilldeer/SM\nkiller/M\nkilling/Y\nkilljoy/S\nkiln/GDSM\nkilo/SM\nkilobaud/M\nkilobit/S\nkilobuck\nkilobyte/S\nkilocycle/MS\nkilogauss/M\nkilogram/MS\nkilohertz/M\nkilohm/M\nkilojoule/MS\nkiloliter/MS\nkilometer/SM\nkiloton/SM\nkilovolt/SM\nkilowatt/SM\nkiloword\nkilt/MDRGZS\nkilter/M\nkimono/MS\nkin/MS\nkind/PSYRT\nkinda\nkinder/U\nkindergarten/MS\nkindergrtner/SM\nkindhearted/YP\nkindheartedness/MS\nkindle/AGRSD\nkindler/M\nkindliness's/U\nkindliness/SM\nkindling/M\nkindly/TUPR\nkindness's\nkindness/US\nkindred/S\nkine/SM\nkinematic/S\nkinematics/M\nkinesics/M\nkinesthesis\nkinesthetic/S\nkinesthetically\nkinetic/S\nkinetically\nkinetics/M\nkinfolk/S\nking/SGYDM\nkingbird/M\nkingdom/SM\nkingfisher/MS\nkinglet/M\nkingliness/M\nkingly/TPR\nkingpin/MS\nkingship/SM\nkink/GSDM\nkinkily\nkinkiness/SM\nkinky/PRT\nkinsfolk/S\nkinship/SM\nkinsman/M\nkinsmen/M\nkinswoman/M\nkinswomen\nkiosk/SM\nkip/MS\nkipped\nkipper/DMSG\nkipping\nkirk/GDMS\nkirsch/S\nkismet/SM\nkiss/DSRBJGZ\nkisser/M\nkit/MDRGS\nkitbag's\nkitchen/GDRMS\nkitchener/M\nkitchenette/SM\nkitchenware/SM\nkite/SM\nkiter/M\nkith/MDG\nkiths\nkitsch/MS\nkitschy\nkitted\nkitten/SGDM\nkittenish/YP\nkittenishness/M\nkitting\nkittiwakes\nkitty/SM\nkiwi/SM\nkiwifruit/S\nkl\nklaxon/M\nkleptomania/MS\nkleptomaniac/SM\nkludge/RSDGMZ\nkludger/M\nkludgey\nklutz/SM\nklutziness/S\nklutzy/TRP\nklystron/MS\nkm\nkn\nknack/SGZRDM\nknacker/M\nknackwurst/MS\nknapsack/MS\nknave/SM\nknavery/MS\nknavish/Y\nknead/GZRDS\nkneader/M\nknee/DSM\nkneecap/MS\nkneecapped\nkneecapping\nkneeing\nkneel/GRS\nkneeler/M\nkneepad/SM\nknell/SMDG\nknelt\nknew\nknick/ZR\nknickerbocker/S\nknickknack/SM\nknife/DSGM\nknight/MDYSG\nknighthood/MS\nknightliness/MS\nknightly/P\nknish/MS\nknit/AU\nknits\nknitted\nknitter/MS\nknitting/SM\nknitwear/M\nknives/M\nknob/MS\nknobbly\nknobby/RT\nknock/GZSJRD\nknockabout/M\nknockdown/S\nknocker/M\nknockoff/S\nknockout/MS\nknockwurst's\nknoll/MDSG\nknot/MS\nknothole/SM\nknotted\nknottiness/M\nknotting/M\nknotty/TPR\nknow/GRBSJ\nknowable/U\nknower/M\nknowhow\nknowing/RYT\nknowingly/U\nknowings/U\nknowledge/SM\nknowledgeable/P\nknowledgeableness/M\nknowledgeably\nknown/SU\nknuckle/DSMG\nknuckleball/R\nknuckleduster\nknucklehead/MS\nknurl/DSG\nkoala/SM\nkohlrabi/M\nkohlrabies\nkola/SM\nkook/GDMS\nkookaburra/SM\nkookiness/S\nkooky/PRT\nkopeck/MS\nkosher/DGS\nkowtow/SGD\nkph\nkraal/SMDG\nkraft/M\nkraut/S!\nkriegspiel/M\nkrill/MS\nkrone/RM\nkronor\nkrypton/SM\nkrna/M\nkrnur\nks\nkt\nkuchen/MS\nkudos/M\nkudzu/SM\nkumquat/SM\nkurtosis/M\nkvetch/DSG\nkw\nkyle/M\nl's\nl/JGVXT\nla/MHLG\nlab/SM\nlabel's\nlabel/GAZRDS\nlabeled/U\nlabeler/M\nlabellings/A\nlabia/M\nlabial/YS\nlabile\nlabiodental\nlabium/M\nlabor/RDMJSZG\nlaboratory/MS\nlabored's/U\nlabored/PMY\nlaboredness/M\nlaborer/M\nlaboring/MY\nlaborings/U\nlaborious/PY\nlaboriousness/MS\nlaborsaving\nlaburnum/SM\nlabyrinth/M\nlabyrinthine\nlabyrinths\nlac/SGMDR\nlace/MS\nlaced/U\nlacer/M\nlacerate/NGVXDS\nlaceration/M\nlaces/U\nlacewing/MS\nlachrymal/S\nlachrymose\nlacing/M\nlack/GRDMS\nlackadaisic\nlackadaisical/Y\nlacker/M\nlackey/SMDG\nlackluster/S\nlaconic\nlaconically\nlacquer/ZGDRMS\nlacquerer/M\nlacrosse/MS\nlactate/MNGSDX\nlactation/M\nlactational/Y\nlacteal\nlactic\nlactose/MS\nlacuna/M\nlacunae\nlacy/RT\nlad/XGSJMND\nladder/GDMS\nladdie/MS\nlade/S\nladed/U\nladen/U\nladened\nladening\nlading/M\nladle/SDGM\nlady/SM\nladybird/SM\nladybug/MS\nladyfinger/SM\nladylike/U\nladylove/MS\nladyship/SM\nlaetrile/S\nlag/ZSR\nlager/DMG\nlaggard/MYSP\nlaggardness/M\nlagged\nlagging/MS\nlagniappe/SM\nlagoon/MS\nlaid/AI\nlain\nlair/GDMS\nlaird/MS\nlaissez\nlaity/SM\nlake/DSRMG\nlaker/M\nlakeside\nlallygag/S\nlallygagged\nlallygagging\nlam/MDRSTG\nlama/SM\nlamasery/MS\nlamb/SRDMG\nlambada/S\nlambaste/SDG\nlambda/SM\nlambency/MS\nlambent/Y\nlambkin/MS\nlambskin/MS\nlambswool\nlame/SPY\nlamebrain/SM\nlamed/M\nlameness/MS\nlament/DGSB\nlamentable/P\nlamentableness/M\nlamentably\nlamentation/SM\nlamented/U\nlamina/M\nlaminae\nlaminar\nlaminate/XNGSD\nlamination/M\nlammed\nlammer\nlamming\nlamp/SGMRD\nlampblack/SM\nlamplight/ZRMS\nlamplighter/M\nlampoon/RDMGS\nlampooner/M\nlamppost/SM\nlamprey/MS\nlampshade/MS\nlanai/SM\nlance/SRDGMZ\nlancer/M\nlancet/MS\nland/SMRDJGZ\nlandau/MS\nlander/I\nlandfall/SM\nlandfill/DSG\nlandforms\nlandhold/JGZR\nlandholder/M\nlanding/M\nlandlady/MS\nlandless\nlandlines\nlandlocked\nlandlord/MS\nlandlubber/SM\nlandmark/GSMD\nlandmass/MS\nlandowner/MS\nlandownership/M\nlandowning/SM\nlands/I\nlandscape/GMZSRD\nlandscaper/M\nlandslid/G\nlandslide/MS\nlandslip\nlandsman/M\nlandsmen\nlandward/S\nlane/SM\nlanguage/MS\nlanguid/PY\nlanguidness/MS\nlanguish/SRDG\nlanguisher/M\nlanguishing/Y\nlanguor/SM\nlanguorous/Y\nlank/PTYR\nlankiness/SM\nlankness/MS\nlanky/PRT\nlanolin/MS\nlantern/GSDM\nlanthanide/M\nlanthanum/MS\nlanyard/MS\nlap/SM\nlapboard/MS\nlapdog/S\nlapel/MS\nlapidary/MS\nlapin/MS\nlapped\nlappet/MS\nlapping\nlaps/SRDG\nlapse/KSDMG\nlapsed/A\nlapser/MA\nlapses/A\nlapsing/A\nlaptop/SM\nlapwing/MS\nlarboard/MS\nlarcenist/S\nlarcenous\nlarceny/MS\nlarch/MS\nlard/MRDSGZ\nlarder/M\nlardy/RT\nlarge/SRTYP\nlargehearted\nlargemouth\nlargeness/SM\nlargess/SM\nlargish\nlargo/S\nlariat/MDGS\nlark/GRDMS\nlarker/M\nlarkspur/MS\nlarva/M\nlarvae\nlarval\nlaryngeal/YS\nlarynges\nlaryngitides\nlaryngitis/M\nlarynx/M\nlas/SRZG\nlasagna/S\nlasagne's\nlascivious/YP\nlasciviousness/MS\nlase\nlaser/M\nlash/JGMSRD\nlashed/U\nlasher/M\nlashing/M\nlass/SM\nlassie/SM\nlassitude/MS\nlasso/GRDMS\nlassoer/M\nlast/JGSYRD\nlaster/M\nlasting/PY\nlastingness/M\nlat/SDRT\nlatch's\nlatch/UGSD\nlatching/M\nlatchkey/SM\nlate/KA\nlatecomer/SM\nlated/A\nlately\nlatency/MS\nlateness/MS\nlatent/YS\nlater/A\nlateral/GDYS\nlateralization\nlatest/S\nlatex/MS\nlath/MSRDGZ\nlathe/M\nlather/RDMG\nlatherer/M\nlathery\nlathing/M\nlaths\nlatices/M\nlatish\nlatitude/SM\nlatitudinal/Y\nlatitudinarian/S\nlatitudinary\nlatrine/MS\nlatte/SR\nlatter/YM\nlattice/SDMG\nlatticework/MS\nlatticing/M\nlaud/RDSBG\nlaudably\nlaudanum/MS\nlaudatory\nlauder/M\nlauds/M\nlaugh/BRDZGJ\nlaughable/P\nlaughableness/M\nlaughably\nlaugher/M\nlaughing/MY\nlaughingstock/SM\nlaughs\nlaughter/MS\nlaunch/AGSD\nlauncher/MS\nlaunching/S\nlaunchpad/S\nlaunder/SDRZJG\nlaundered/U\nlaunderer/M\nlaunderette/MS\nlaundress/MS\nlaundrette/S\nlaundromat/S\nlaundry/MS\nlaundryman/M\nlaundrymen\nlaundrywoman/M\nlaundrywomen\nlaura/M\nlaureate/DSNG\nlaureateship/SM\nlaurel/SGMD\nlava/SM\nlavage/MS\nlavaliere/MS\nlavatory/MS\nlave/GDS\nlavender/MDSG\nlavish/SRDYPTG\nlavishness/MS\nlaw/SMDG\nlawbreaker/SM\nlawbreaking/MS\nlawful/PUY\nlawfulness/SMU\nlawgiver/MS\nlawgiving/M\nlawless/PY\nlawlessness/MS\nlawmaker/MS\nlawmaking/SM\nlawman/M\nlawmen\nlawn/SM\nlawnmower/S\nlawrencium/SM\nlawsuit/MS\nlawyer/DYMGS\nlax/PTSRY\nlaxative/PSYM\nlaxativeness/M\nlaxer/A\nlaxes/A\nlaxity/SM\nlaxness/SM\nlay/CZGSR\nlayabout/MS\nlayaway/S\nlayer's/IC\nlayer/GJDM\nlayered/C\nlayering/M\nlayette/SM\nlayman/M\nlaymen\nlayoff/MS\nlayout/SM\nlayover/SM\nlaypeople\nlayperson/S\nlays/AI\nlayup/MS\nlaywoman/M\nlaywomen\nlaze/DSG\nlazily\nlaziness/MS\nlazuli/M\nlazy/PTSRDG\nlazybones/M\nlb\nlbs\nlea/MS\nleach/SDG\nleachate\nlead/SGZXJRDN\nleaded/U\nleaden/PGDY\nleadenness/M\nleader/M\nleaderless\nleadership/MS\nleadsman/M\nleadsmen\nleaf/GSDM\nleafage/MS\nleafhopper/M\nleafiness/M\nleafless\nleaflet/SDMG\nleafstalk/SM\nleafy/PTR\nleague/RSDMZG\nleaguer/M\nleak/GSRDM\nleakage/SM\nleaker/M\nleakiness/MS\nleaky/PRT\nlean/YRDGTJSP\nleaner/M\nleaning/M\nleanness/MS\nleap/RDGZS\nleaper/M\nleapfrog/SM\nleapfrogged\nleapfrogging\nlearn/SZGJRD\nlearned/UA\nlearnedly\nlearnedness/M\nlearner/M\nlearning/M\nlearns/UA\nleas/SRDGZ\nlease's\nlease/ARSDG\nleaseback/MS\nleasehold/SRMZ\nleaseholder/M\nleaser/MA\nleash's\nleash/UGSD\nleasing/M\nleast/S\nleastwise\nleather/MDSG\nleatherette/S\nleathern\nleatherneck/SM\nleathery\nleave/SRDJGZ\nleaven/DMJGS\nleavened/U\nleavening/M\nleaver/M\nleaves/M\nleaving/M\nlebensraum\nlecher/DMGS\nlecherous/YP\nlecherousness/MS\nlechery/MS\nlecithin/SM\nlectern/SM\nlecture/RSDZMG\nlecturer/M\nlectureship/SM\nled\nledge/SRMZ\nledger/DMG\nlee/MZRS\nleech/MSDG\nleek/SM\nleer/DG\nleeriness/MS\nleering/Y\nleery/PTR\nleeward/S\nleeway/MS\nleft/TRS\nleftism/SM\nleftist/SM\nleftmost\nleftover/MS\nleftward/S\nlefty/SM\nleg/MS\nlegacy/MS\nlegal/SY\nlegalese/MS\nlegalism/SM\nlegalistic\nlegality/MS\nlegalization/MS\nlegalize/DSG\nlegalized/U\nlegate's/C\nlegate/AXCNGSD\nlegatee/MS\nlegation/AMC\nlegato/SM\nlegend/SM\nlegendarily\nlegendary/S\nlegerdemain/SM\nlegged\nlegginess/MS\nlegging/MS\nleggy/PRT\nleghorn/SM\nlegibility/MS\nlegible\nlegibly\nlegion/SM\nlegionary/S\nlegionnaire/SM\nlegislate/SDXVNG\nlegislation/M\nlegislative/SY\nlegislator/SM\nlegislature/MS\nlegit/S\nlegitimacy/MS\nlegitimate/SDNGY\nlegitimation/M\nlegitimatize/SDG\nlegitimization/MS\nlegitimize/RSDG\nlegless\nlegman/M\nlegmen\nlegroom/MS\nlegstraps\nlegume/SM\nleguminous\nlegwork/SM\nlei/MS\nleisure/SDYM\nleisureliness/MS\nleisurely/P\nleisurewear\nleitmotif/SM\nleitmotiv/MS\nlemma/MS\nlemme/GJ\nlemming/M\nlemon/GSDM\nlemonade/SM\nlemony\nlemur/MS\nlend/SRGZ\nlender/M\nlength/MNYX\nlengthen/GRD\nlengthener/M\nlengthily\nlengthiness/MS\nlengths\nlengthwise\nlengthy/TRP\nlenience/S\nleniency/MS\nlenient/SY\nlenitive/S\nlens/SRDMJGZ\nlent/A\nlenticular\nlentil/SM\nlento/S\nleonine\nleopard/MS\nleopardess/SM\nleopardskin\nleotard/MS\nleper/SM\nleprechaun/SM\nleprosy/MS\nleprous\nlepta\nlepton/SM\nlesbian/MS\nlesbianism/MS\nlesion/DMSG\nless/U\nlessee/MS\nlessen/GDS\nlesser\nlesses\nlessing\nlesson/DMSG\nlessor/MS\nlest/R\nlet/ISM\nletdown/SM\nlethal/YS\nlethality/M\nlethargic\nlethargically\nlethargy/MS\nletter/JSZGRDM\nletterbox/S\nlettered/U\nletterer/M\nletterhead/SM\nlettering/M\nletterman/M\nlettermen\nletterpress/MS\nletting/S\nlettuce/SM\nletup/MS\nleukemia/SM\nleukemic/S\nleukocyte/MS\nlevee/SDM\nleveeing\nlevel/STZGRDYP\nleveled/U\nleveler/M\nlevelheaded/P\nlevelheadedness/S\nleveling/U\nlevelness/SM\nlever/SDMG\nleverage/MGDS\nleviathan/MS\nlevier/M\nlevitate/XNGDS\nlevitation/M\nlevity/MS\nlevy/SRDZG\nlewd/PYRT\nlewdness/MS\nlewis/M\nlex\nlexeme/MS\nlexical/Y\nlexicographer/MS\nlexicographic\nlexicographical/Y\nlexicography/SM\nlexicon/SM\nlg\nliability/SAM\nliable/AP\nliaise/GSD\nliaison/SM\nliar/MS\nlib/MS\nlibation/SM\nlibbed\nlibbing\nlibel/GMRDSZ\nlibeler/M\nlibelous/Y\nliberal/YSP\nliberalism/MS\nliberality/MS\nliberalization/SM\nliberalize/GZSRD\nliberalized/U\nliberalizer/M\nliberalness/MS\nliberate/NGDSCX\nliberation/MC\nliberationists\nliberator/SCM\nlibertarian/MS\nlibertarianism/M\nlibertine/MS\nliberty/MS\nlibidinal\nlibidinous/PY\nlibidinousness/M\nlibido/MS\nlibrarian/MS\nlibrary/MS\nlibretoes\nlibretos\nlibrettist/MS\nlibretto/MS\nlice/M\nlicense/MGBRSD\nlicensed/AU\nlicensee/SM\nlicenser/M\nlicenses/A\nlicensing/A\nlicensor/M\nlicentiate/MS\nlicentious/PY\nlicentiousness/MS\nlichee's\nlichen/DMGS\nlicit/Y\nlick/GRDSJ\nlicked/U\nlicker/M\nlickerish\nlicking/M\nlicorice/SM\nlid/MS\nlidded\nlidding\nlidless\nlido/MS\nlie/DRS\nlied/MR\nlief/TSR\nliefs/A\nliege/SR\nlien/SM\nlier/IMA\nlies/A\nlieu/SM\nlieut\nlieutenancy/MS\nlieutenant/SM\nlife/MZR\nlifeblood/SM\nlifeboat/SM\nlifebuoy/S\nlifeforms\nlifeguard/MDSG\nlifeless/PY\nlifelessness/SM\nlifelike/P\nlifelikeness/M\nlifeline/SM\nlifelong\nlifer/M\nlifesaver/SM\nlifesaving/S\nlifespan/S\nlifestyle/S\nlifetaking\nlifetime/MS\nlifework/MS\nlift/GZMRDS\nlifter/M\nliftoff/MS\nligament/MS\nligand/MS\nligate/XSDNG\nligation/M\nligature/DSGM\nlight's\nlight/ADSCG\nlighted/U\nlighten/ZGDRS\nlightener/M\nlightening/M\nlighter/CM\nlightered\nlightering\nlighters\nlightest\nlightface/SDM\nlightheaded\nlighthearted/PY\nlightheartedness/MS\nlighthouse/MS\nlighting/MS\nlightly\nlightness/MS\nlightning/SMD\nlightproof\nlightship/SM\nlightweight/S\nligneous\nlignite/MS\nlignum\nlikability/MS\nlikable/P\nlikableness/MS\nlike/USPBY\nlikeability's\nliked/E\nlikelihood/MSU\nlikely/UPRT\nliken/GSD\nlikeness/MSU\nliker's\nliker/E\nlikes/E\nlikest\nlikewise\nliking/SM\nlilac/MS\nlilliputian/S\nlilt/MDSG\nlilting/YP\nlily/MSD\nlimb/SGZRDM\nlimber/RDYTGP\nlimbered/U\nlimberness/SM\nlimbers/U\nlimbic\nlimbless\nlimbo/GDMS\nlime/DSMG\nlimeade/SM\nlimekiln/M\nlimelight/DMGS\nlimerick/SM\nlimestone/SM\nlimit's\nlimit/CSZGRD\nlimitability\nlimitably\nlimitation/MCS\nlimited/PSY\nlimitedly/U\nlimitedness/M\nlimiter/M\nlimiting/S\nlimitless/PY\nlimitlessness/SM\nlimn/GSD\nlimo/S\nlimousine/SM\nlimp/SGTPYRD\nlimper/M\nlimpet/SM\nlimpid/YP\nlimpidity/MS\nlimpidness/SM\nlimpness/MS\nlimy/TR\nlinage/MS\nlinchpin/MS\nlinden/MS\nline's\nline/AGDS\nlineage/SM\nlineal/Y\nlineament/MS\nlinear/Y\nlinearity/MS\nlinearize/SDGNB\nlinebacker/SM\nlined/U\nlinefeed\nlineman/M\nlinemen\nlinen/SM\nliner/SM\nlinesman/M\nlinesmen\nlineup/S\nling/ZR\nlinger/ZGJRD\nlingerer/M\nlingerie/SM\nlingering/Y\nlingo/M\nlingoes\nlingua/M\nlingual/SY\nlinguine\nlinguini's\nlinguist/SM\nlinguistic/S\nlinguistically\nlinguistics/M\nliniment/MS\nlining/SM\nlink's\nlink/USGD\nlinkable\nlinkage/SM\nlinked/A\nlinker/S\nlinking/S\nlinkup/S\nlinnet/SM\nlino/M\nlinoleum/SM\nlinseed/SM\nlint/SMR\nlintel/SM\nlinter/M\nlinty/RST\nlion/MS\nlioness/SM\nlionhearted\nlionization/SM\nlionize/ZRSDG\nlionizer/M\nlip/MS\nlipase/M\nlipid/MS\nliposuction/S\nlipped\nlipper\nlipping\nlippy/TR\nlipread/GSRJ\nlipstick/MDSG\nliq\nliquefaction/SM\nliquefier/M\nliquefy/DRSGZ\nliqueur/DMSG\nliquid/SPMY\nliquidate/GNXSD\nliquidation/M\nliquidator/SM\nliquidity/SM\nliquidize/ZGSRD\nliquidizer/M\nliquidness/M\nliquor/SDMG\nliquorice/SM\nliquorish\nlira/M\nlire\nlisle/SM\nlisp/MRDGZS\nlisper/M\nlissome/P\nlissomeness/M\nlissomness/M\nlist/JMRDNGZXS\nlisted/U\nlisten/ZGRD\nlistener/M\nlister/M\nlisting/M\nlistless/PY\nlistlessness/SM\nlit/RZS\nlitany/MS\nlitchi/SM\nlite/S\nliter/M\nliteracy/MS\nliteral/PYS\nliteralism/M\nliteralistic\nliteralness/MS\nliterariness/SM\nliterary/P\nliterate/YNSP\nliterati\nliteration/M\nliterature/SM\nlithe/PRTY\nlitheness/SM\nlithesome\nlithium/SM\nlithograph/DRMGZ\nlithographer/M\nlithographic\nlithographically\nlithographs\nlithography/MS\nlithology/M\nlithosphere/MS\nlithospheric\nlitigant/MS\nlitigate/NGXDS\nlitigation/M\nlitigator/SM\nlitigious/PY\nlitigiousness/MS\nlitmus/SM\nlitotes/M\nlitter/SZGRDM\nlitterbug/SM\nlittle/RSPT\nlittleneck/M\nlittleness/SM\nlittoral/S\nlittrateur/S\nliturgic/S\nliturgical/Y\nliturgics/M\nliturgist/MS\nliturgy/SM\nlivability/MS\nlivable/U\nlivableness/M\nlivably\nlive/YHZTGJDSRPB\nlived/A\nlivelihood/SM\nliveliness/SM\nlivelong/S\nlively/RTP\nliven/SDG\nliveness/M\nliver's\nliver/CSGD\nliveried\nliverish\nliverwort/SM\nliverwurst/SM\nlivery/CMS\nliveryman/MC\nliverymen/C\nlives's\nlives/A\nlivestock/SM\nlivid/YP\nlividness/M\nliving/YP\nlivingness/M\nlizard/MS\nll/C\nllama/SM\nllano/SM\nlo\nload's/A\nload/SURDZG\nloadable\nloaded/A\nloader/MU\nloading/MS\nloads/A\nloadstar's\nloadstone's\nloaf/SRDMGZ\nloafer/M\nloam/SMDG\nloamy/RT\nloan/SGZRDMB\nloaner/M\nloaning/M\nloansharking/S\nloanword/S\nloath/JPSRDYZG\nloathe\nloather/M\nloathing/M\nloathness/M\nloathsome/PY\nloathsomeness/MS\nloaves/M\nlob/MDSG\nlobar\nlobbed\nlobber/MS\nlobbing\nlobby/GSDM\nlobbyist/MS\nlobe/SM\nlobotomist\nlobotomize/GDS\nlobotomy/MS\nlobster/MDGS\nlobular/Y\nlobularity\nlobule/SM\nlocal/SGDY\nlocale/MS\nlocalisms\nlocality/MS\nlocalization/MS\nlocalize/ZGDRS\nlocalized/U\nlocalizer/M\nlocalizes/U\nlocatable\nlocate/AXESDGN\nlocater/M\nlocation/EMA\nlocational/Y\nlocative/S\nlocator's\nloch/M\nlochs\nloci/M\nlock's\nlock/UGSD\nlockable\nlocked/A\nlocker/SM\nlocket/SM\nlocking/S\nlockjaw/SM\nlocknut/M\nlockout/MS\nlocksmith/MG\nlocksmithing/M\nlocksmiths\nlockstep/S\nlockup/MS\nloco/SDMG\nlocomotion/SM\nlocomotive/YMS\nlocomotor\nlocomotory\nlocoweed/MS\nlocus/M\nlocust/SM\nlocution/MS\nlode/SM\nlodestar/MS\nlodestone/MS\nlodge/GMZSRDJ\nlodged/E\nlodgepole\nlodger/M\nlodges/E\nlodging/M\nlodgment/M\nloft/SGMRD\nlofter/M\nloftily\nloftiness/SM\nlofty/PTR\nlog's/K\nlog/SM\nloganberry/SM\nlogarithm/MS\nlogarithmic\nlogarithmically\nlogbook/MS\nloge/SMNX\nlogged/U\nlogger/SM\nloggerhead/SM\nloggia/SM\nlogging/MS\nlogic/SM\nlogical/SPY\nlogicality/MS\nlogicalness/M\nlogician/SM\nlogin/S\nlogion/M\nlogistic/MS\nlogistical/Y\nlogjam/SM\nlogo/SM\nlogotype/MS\nlogout\nlogrolling/SM\nlogy/RT\nloin/SM\nloincloth/M\nloincloths\nloiter/RDJSZG\nloiterer/M\nloll/RDGS\nloller/M\nlollipop/MS\nlolly/SM\nlone/PYZR\nloneliness/SM\nlonely/TRP\nloneness/M\nloner/M\nlonesome/PSY\nlonesomeness/MS\nlong/JGTYRDPS\nlongboat/MS\nlongbow/SM\nlonged/K\nlongeing\nlonger/K\nlongevity/MS\nlonghair/SM\nlonghand/SM\nlonghorn/SM\nlonging/MY\nlongish\nlongitude/MS\nlongitudinal/Y\nlongness/M\nlongs/K\nlongshoreman/M\nlongshoremen\nlongsighted\nlongstanding\nlongsword\nlongterm\nlongtime\nlongueur/SM\nlongways\nlongword/SM\nloofah/M\nloofahs\nlook/GZRDS\nlookahead\nlookalike/S\nlooker/M\nlookout/MS\nlookup/SM\nloom/MDGS\nlooming/M\nloon/MS\nloony/SRT\nloop/MRDGS\nlooper/M\nloophole/MGSD\nloopy/TR\nloose/SRDPGTY\nloosed/U\nlooseleaf\nloosen/UDGS\nloosener/M\nlooseness/MS\nlooses/U\nloosing/M\nloot/MRDGZS\nlooter/M\nlop/SDRG\nlope/S\nloper/M\nlopped\nlopper/MS\nlopping\nlopsided/YP\nlopsidedness/SM\nloquacious/YP\nloquaciousness/MS\nloquacity/SM\nlord/MYDGS\nlording/M\nlordliness/SM\nlordly/PTR\nlordship/SM\nlore/MS\nlorgnette/SM\nloris/SM\nlorn\nlorry/SM\nlorryload/S\nlose/ZGJBSR\nloser/M\nloss/SM\nlossage\nlossless\nlossy/RT\nlost/P\nlot/MS\nlotion/MS\nlotted\nlotter\nlottery/MS\nlotting\nlotto/MS\nlotus/SM\nloud/YRNPT\nlouden/DG\nloudhailer/S\nloudly/RT\nloudmouth/DM\nloudmouths\nloudness/MS\nloudspeaker/SM\nloudspeaking\nlounge/SRDZG\nlounger/M\nlour/GSD\nlouse's\nlouse/CSDG\nlousewort/M\nlousily\nlousiness/MS\nlousy/PRT\nlout/SGMD\nloutish/YP\nloutishness/M\nlouver/DMS\nlovable/U\nlovableness/MS\nlovably\nlove/DSRMYZGJB\nlovebird/SM\nlovechild\nloved/U\nloveless/YP\nlovelessness/M\nlovelies\nloveliness/UM\nlovelinesses\nlovelorn/P\nlovelornness/M\nlovely/URPT\nlovemaking/SM\nlover/YMG\nlovesick\nlovestruck\nloving/U\nlovingly\nlovingness/M\nlow/PDRYSZTG\nlowborn\nlowboy/SM\nlowbrow/MS\nlowdown/S\nlower/DG\nlowercase/GSD\nlowermost\nlowish\nlowland/RMZS\nlowlife/SM\nlowlight/MS\nlowliness/MS\nlowly/PTR\nlowness/MS\nlox/MDSG\nloyal/EY\nloyaler\nloyalest\nloyalism/SM\nloyalist/SM\nloyalty/EMS\nlozenge/SDM\nls\nltd\nluau/MS\nlubber/YMS\nlube/DSMG\nlubricant/SM\nlubricate/VNGSDX\nlubrication/M\nlubricator/MS\nlubricious/Y\nlubricity/SM\nlucent/Y\nlucid/YP\nlucidity/MS\nlucidness/MS\nluck/GSDM\nluckier/U\nluckily/U\nluckiness/UMS\nluckless\nlucky/RSPT\nlucrative/YP\nlucrativeness/SM\nlucre/MS\nlucubrate/GNSDX\nlucubration/M\nludicrous/PY\nludicrousness/SM\nludo/M\nluff/GSDM\nlug/RS\nluge/MC\nluggage/SM\nlugged\nlugger/SM\nlugging\nlugsail/SM\nlugubrious/YP\nlugubriousness/MS\nlukewarm/PY\nlukewarmness/SM\nlull/SDG\nlullaby/GMSD\nlulu/M\nlumbago/SM\nlumbar/S\nlumber/RDMGZSJ\nlumberer/M\nlumbering/M\nlumberjack/MS\nlumberman/M\nlumbermen\nlumberyard/MS\nlumen/M\nluminance/M\nluminary/MS\nluminescence/SM\nluminescent\nluminosity/MS\nluminous/YP\nluminousness/M\nlummox/MS\nlump/SGMRDN\nlumper/M\nlumpiness/MS\nlumpish/YP\nlumpishness/M\nlumpy/TPR\nlunacy/MS\nlunar/S\nlunary\nlunate/YND\nlunatic/S\nlunation/M\nlunch/GMRSD\nluncheon/SMDG\nluncheonette/SM\nluncher/M\nlunchpack\nlunchroom/MS\nlunchtime/MS\nlune/M\nlung/SGRDM\nlunge/MS\nlunger/M\nlungfish/SM\nlungful\nlunkhead/SM\nlupine/SM\nlupus/SM\nlurch/RSDG\nlurcher/M\nlure/DSRG\nlurer/M\nlurex\nlurid/YP\nluridness/SM\nlurk/GZSRD\nlurker/M\nluscious/PY\nlusciousness/MS\nlush/YSRDGTP\nlushness/MS\nlust/MRDGZS\nluster/GDM\nlustering/M\nlusterless\nlustful/PY\nlustfulness/M\nlustily\nlustiness/MS\nlustrous/PY\nlustrousness/M\nlusty/PRT\nlutanist/MS\nlute/DSMG\nlutenist/MS\nlutetium/MS\nluting/M\nluxe/MS\nluxuriance/MS\nluxuriant/Y\nluxuriate/GNSDX\nluxuriation/M\nluxurious/PY\nluxuriousness/SM\nluxury/MS\nlyceum/MS\nlychee's\nlycopodium/M\nlye/JSMG\nlying/Y\nlymph/M\nlymphatic/S\nlymphocyte/SM\nlymphoid\nlymphoma/MS\nlymphs\nlynch/ZGRSDJ\nlyncher/M\nlynching/M\nlynx/MS\nlyre/SM\nlyrebird/MS\nlyric/S\nlyrical/YP\nlyricalness/M\nlyricism/SM\nlyricist/SM\nlysine/M\nm's/K\nm/ASK\nma'am\nma/MH\nmac/SGMDR\nmacabre/Y\nmacadam/SM\nmacadamize/SDG\nmacaque/SM\nmacaroni/SM\nmacaroon/MS\nmacaw/SM\nmace/MS\nmacer/M\nmacerate/DSXNG\nmaceration/M\nmachete/SM\nmachinate/SDXNG\nmachination/M\nmachine/MGSDB\nmachinelike\nmachinery/SM\nmachinist/MS\nmachismo/SM\nmacho/S\nmacintosh's\nmack/M\nmackerel/SM\nmackinaw/SM\nmackintosh/SM\nmacram/S\nmacro/SM\nmacrobiotic/S\nmacrobiotics/M\nmacrocosm/MS\nmacrodynamic\nmacroeconomic/S\nmacroeconomics/M\nmacromolecular\nmacromolecule/SM\nmacron/MS\nmacrophage/SM\nmacroscopic\nmacroscopically\nmacrosimulation\nmacrosocioeconomic\nmad/PSY\nmadam/SM\nmadame/M\nmadcap/S\nmadded\nmadden/GSD\nmaddening/Y\nmadder/MS\nmaddest\nmadding\nmade/AU\nmademoiselle/MS\nmadhouse/SM\nmadman/M\nmadmen\nmadness/SM\nmadras/SM\nmadrigal/MSG\nmadwoman/M\nmadwomen\nmaelstrom/SM\nmaestro/MS\nmafia/S\nmafiosi\nmafioso/M\nmag/S\nmagazine/DSMG\nmagenta/MS\nmagged\nmagging\nmaggot/MS\nmaggoty/RT\nmagi\nmagic/SM\nmagical/Y\nmagician/MS\nmagicked\nmagicking\nmagisterial/Y\nmagistracy/MS\nmagistrate/MS\nmagma/SM\nmagnanimity/SM\nmagnanimosity\nmagnanimous/PY\nmagnate/SM\nmagnesia/MS\nmagnesite/M\nmagnesium/SM\nmagnet/SM\nmagnetic/S\nmagnetically\nmagnetics/M\nmagnetism/SM\nmagnetite/SM\nmagnetizable\nmagnetization/ASCM\nmagnetize/CGDS\nmagnetized/U\nmagneto/MS\nmagnetodynamics\nmagnetohydrodynamical\nmagnetohydrodynamics/M\nmagnetometer/MS\nmagnetosphere/M\nmagnetron/M\nmagnification/M\nmagnificence/SM\nmagnificent/Y\nmagnified/U\nmagnify/DRSGNXZ\nmagniloquence/MS\nmagniloquent\nmagnitude/SM\nmagnolia/SM\nmagnum/SM\nmagpie/SM\nmaharajah/M\nmaharajahs\nmaharanee's\nmaharani/MS\nmaharishi/SM\nmahatma/SM\nmahjong's\nmahogany/MS\nmahout/SM\nmaid/SMNX\nmaiden/YM\nmaidenhair/MS\nmaidenhead/SM\nmaidenhood/SM\nmaidenly/P\nmaidservant/MS\nmaier\nmail/BSJGZMRD\nmailbag/MS\nmailbox/MS\nmailer/M\nmaillot/SM\nmailman/M\nmailmen\nmaim/SGZRD\nmaimed/P\nmaimedness/M\nmaimer/M\nmain/SA\nmainbrace/M\nmainframe/MS\nmainland/SRMZ\nmainlander/M\nmainline/RSDZG\nmainliner/M\nmainly\nmainmast/SM\nmains/M\nmainsail/SM\nmainspring/SM\nmainstay/MS\nmainstream/DRMSG\nmaintain/BRDZGS\nmaintainability\nmaintainable/U\nmaintained/U\nmaintainer/M\nmaintenance/SM\nmaintop/SM\nmaiolica's\nmaisonette/MS\nmaize/MS\nmajestic\nmajestically\nmajesty/MS\nmajolica/SM\nmajor/DMGS\nmajordomo/S\nmajorette/SM\nmajority/SM\nmakable\nmake/UGSA\nmakefile/S\nmakeover/S\nmaker/SM\nmakeshift/S\nmakeup/MS\nmaking/SM\nmalachite/SM\nmaladapt/DV\nmaladjust/DLV\nmaladjustment/MS\nmaladministration\nmaladroit/YP\nmaladroitness/MS\nmalady/MS\nmalaise/SM\nmalamute/SM\nmalaprop\nmalapropism/SM\nmalaria/MS\nmalarial\nmalarious\nmalarkey/SM\nmalathion/S\nmalcontent/SMD\nmalcontented/PY\nmalcontentedness/M\nmale/PSM\nmaledict\nmalediction/MS\nmalefaction/MS\nmalefactor/MS\nmalefic\nmaleficence/MS\nmaleficent\nmaleness/MS\nmalevolence/S\nmalevolencies\nmalevolent/Y\nmalfeasance/SM\nmalfeasant\nmalformation/MS\nmalformed\nmalfunction/SDG\nmalice/MGSD\nmalicious/YU\nmaliciousness/MS\nmalign/GSRDYZ\nmalignancy/SM\nmalignant/YS\nmalignity/MS\nmalinger/GZRDS\nmalingerer/M\nmall/SGMD\nmallard/SM\nmalleability/SM\nmalleable/P\nmalleableness/M\nmallet/MS\nmallow/MS\nmalnourished\nmalnutrition/SM\nmalocclusion/MS\nmalodorous\nmalposed\nmalpractice/SM\nmalt/SGMD\nmalted/S\nmalting/M\nmaltose/SM\nmaltreat/GDSL\nmaltreatment/S\nmalty/RT\nmama/SM\nmamba/SM\nmambo/GSDM\nmamma's\nmammal/SM\nmammalian/SM\nmammary\nmammogram/S\nmammography/S\nmammon/SM\nmammoth/M\nmammoths\nmammy/SM\nman's\nman/USY\nmanacle/SDMG\nmanage/ZLGRSD\nmanageability/S\nmanageable/U\nmanageableness\nmanaged/U\nmanagement/SM\nmanager/M\nmanageress/M\nmanagerial/Y\nmanagership/M\nmananas\nmanatee/SM\nmanciple/M\nmandala/SM\nmandamus/GMSD\nmandarin/MS\nmandate/SDMG\nmandatory/S\nmandible/MS\nmandibular\nmandolin/MS\nmandrake/MS\nmandrel/SM\nmandrill/SM\nmane/MDS\nmaneuver/MRDSGB\nmaneuverability/MS\nmaneuverer/M\nmanful/Y\nmanganese/MS\nmange/GMSRDZ\nmanger/M\nmanginess/S\nmangle/RSDG\nmangler/M\nmango/M\nmangoes\nmangrove/MS\nmangy/PRT\nmanhandle/GSD\nmanhole/MS\nmanhood/MS\nmanhunt/SM\nmania/SM\nmaniac/SM\nmaniacal/Y\nmanic/S\nmanically\nmanicure/MGSD\nmanicurist/SM\nmanifest/YDPGS\nmanifestation/SM\nmanifesto/GSDM\nmanifold/GPYRDMS\nmanifolder/M\nmanifoldness/M\nmanikin/MS\nmanila/S\nmanilla's\nmanioc/SM\nmanipulability\nmanipulable\nmanipulate/SDXBVGN\nmanipulative/PM\nmanipulator/MS\nmanipulatory\nmankind/M\nmanlike\nmanliness's/U\nmanliness/SM\nmanly/URPT\nmanna/MS\nmanned/U\nmannequin/MS\nmanner/SDYM\nmannered/U\nmannerism/SM\nmannerist/M\nmannerliness/MU\nmannerly/UP\nmannikin's\nmanning/U\nmannish/YP\nmannishness/SM\nmanometer/SM\nmanor/MS\nmanorial\nmanpower/SM\nmanqu/M\nmans/S\nmansard/SM\nmanse/XNM\nmanservant/M\nmansion/M\nmanslaughter/SM\nmanta/MS\nmantel/SM\nmantelpiece/MS\nmantes\nmantilla/MS\nmantis/SM\nmantissa/SM\nmantle's\nmantle/ESDG\nmantling/M\nmantra/MS\nmantrap/SM\nmanual/SMY\nmanufacture/JZGDSR\nmanufacturer/M\nmanumission/MS\nmanumit/S\nmanumitted\nmanumitting\nmanure/RSDMZG\nmanuscript/MS\nmany\nmange/GSD\nmap/SM\nmaple/MS\nmapmaker/S\nmappable\nmapped/UA\nmapper/S\nmapping/MS\nmaps/AU\nmar/S\nmarabou/MS\nmarabout's\nmaraca/MS\nmaraschino/SM\nmarathon/MRSZ\nmarathoner/M\nmaraud/ZGRDS\nmarauder/M\nmarble/JRSDMG\nmarbleize/GSD\nmarbler/M\nmarbling/M\nmarch/RSDZG\nmarcher/M\nmarchioness/SM\nmare/MS\nmargarine/MS\nmargarita/SM\nmargin/GSDM\nmarginal/YS\nmarginalia\nmarginality\nmarginalization\nmarginalize/SDG\nmaria/M\nmariachi/SM\nmarigold/MS\nmarijuana/SM\nmarimba/SM\nmarina/MS\nmarinade/MGDS\nmarinara/SM\nmarinate/NGXDS\nmarination/M\nmarine/ZRS\nmariner/M\nmarionette/MS\nmarital/Y\nmaritime/R\nmarjoram/SM\nmark/GZRDMBSJ\nmarkdown/SM\nmarked/AU\nmarkedly\nmarker/M\nmarket/GSMRDJBZ\nmarketability/SM\nmarketable/U\nmarketeer/S\nmarketer/M\nmarketing/M\nmarketplace/MS\nmarking/M\nmarkka/M\nmarkkaa\nmarks/A\nmarksman/M\nmarksmanship/S\nmarksmen\nmarkup/SM\nmarl/MDSG\nmarlin/SM\nmarlinespike/SM\nmarmalade/MS\nmarmoreal\nmarmoset/MS\nmarmot/SM\nmaroon/GRDS\nmarque/SM\nmarquee/MS\nmarquess/MS\nmarquetry/SM\nmarquis/SM\nmarquise/M\nmarquisette/MS\nmarred/U\nmarriage/ASM\nmarriageability/SM\nmarriageable\nmarried/US\nmarring\nmarrow/GDMS\nmarrowbone/MS\nmarry/SDGA\nmarsh/MS\nmarshal/GMDRSZ\nmarshaller\nmarshallings\nmarshiness/M\nmarshland/MS\nmarshmallow/SM\nmarshy/PRT\nmarsupial/MS\nmart/MDNGXS\nmarten/M\nmartial/Y\nmartin/SM\nmartinet/SM\nmartingale/MS\nmartini/MS\nmartyr/GDMS\nmartyrdom/SM\nmarvel/DGS\nmarvelous/PY\nmarzipan/SM\nmas/SRZ\nmasc\nmascara/SGMD\nmascot/SM\nmasculine/PYS\nmasculineness/M\nmasculinity/SM\nmaser/M\nmash/JGZMSRD\nmask/GZSRDMJ\nmasked/U\nmasker/M\nmasks/U\nmasochism/MS\nmasochist/MS\nmasochistic\nmasochistically\nmason/SDMG\nmasonic\nmasonry/MS\nmasque/RSMZ\nmasquer/M\nmasquerade/RSDGMZ\nmasquerader/M\nmass/VGSD\nmassacre/DRSMG\nmassage/SRDMG\nmassager/M\nmasseur/MS\nmasseuse/SM\nmassif/SM\nmassing/R\nmassive/YP\nmassiveness/SM\nmassless\nmast/GZSMRD\nmastectomy/MS\nmaster/JGDYM\nmasterclass\nmastered/A\nmasterful/YP\nmasterfulness/M\nmasterliness/M\nmasterly/P\nmastermind/GDS\nmasterpiece/MS\nmastership/M\nmasterstroke/MS\nmasterwork/S\nmastery/MS\nmasthead/SDMG\nmastic/SM\nmasticate/SDXGN\nmastication/M\nmastiff/MS\nmastodon/MS\nmastoid/S\nmasturbate/SDNGX\nmasturbation/M\nmasturbatory\nmat/SJGMDR\nmatador/SM\nmatch's/A\nmatch/BMRSDZGJ\nmatchable/U\nmatchbook/SM\nmatchbox/SM\nmatched/UA\nmatcher/M\nmatches/A\nmatchless/Y\nmatchlock/MS\nmatchmake/GZJR\nmatchmaker/M\nmatchmaking/M\nmatchplay\nmatchstick/MS\nmatchwood/SM\nmate/IMS\nmated/U\nmater/M\nmaterial/SPYM\nmaterialism/SM\nmaterialist/SM\nmaterialistic\nmaterialistically\nmateriality/M\nmaterialization/SM\nmaterialize/CDS\nmaterialized/A\nmaterializer/SM\nmaterializes/A\nmaterializing\nmaterialness/M\nmaternal/Y\nmaternity/MS\nmates/U\nmath/M\nmathematic/S\nmathematical/Y\nmathematician/SM\nmathematics/M\nmaths\nmating/M\nmatins/M\nmatine/S\nmatriarch/M\nmatriarchal\nmatriarchs\nmatriarchy/MS\nmatrices\nmatricidal\nmatricide/MS\nmatriculate/XSDGN\nmatriculation/M\nmatrimonial/Y\nmatrimony/SM\nmatrix/M\nmatron/YMS\nmatt's\nmatte/JGMZSRD\nmatter/GDM\nmatting/M\nmattins's\nmattock/MS\nmattress/MS\nmaturate/DSNGVX\nmaturation/M\nmaturational\nmature/RSDTPYG\nmatureness/M\nmaturer/M\nmaturity/MS\nmatzo/SHM\nmatzot\nmatriel/MS\nmaudlin/Y\nmaul/RDGZS\nmauler/M\nmaunder/GDS\nmausoleum/SM\nmauve/SM\nmaven/S\nmaverick/SMDG\nmavin's\nmaw/SGMD\nmawkish/PY\nmawkishness/SM\nmax/GDS\nmaxi/S\nmaxilla/M\nmaxillae\nmaxillary/S\nmaxim/SM\nmaxima's\nmaximal/SY\nmaximality\nmaximization/SM\nmaximize/RSDZG\nmaximizer/M\nmaximum/MYS\nmaxwell/M\nmay/EGS\nmaybe/S\nmayday/S\nmayer\nmayest\nmayflower/SM\nmayfly/MS\nmayhap\nmayhem/MS\nmayn't\nmayo/S\nmayonnaise/MS\nmayor/MS\nmayoral\nmayoralty/MS\nmayoress/MS\nmayorship/M\nmaypole/MS\nmayst\nmaze/MGDSR\nmazed/YP\nmazedness/SM\nmazurka/SM\nmaana/M\nmdse\nme/G\nmead/SM\nmeadow/MS\nmeadowland\nmeadowlark/SM\nmeadowsweet/M\nmeager/PY\nmeagerness/SM\nmeagres\nmeal/MDGS\nmealiness/MS\nmealtime/MS\nmealy/PRST\nmealybug/S\nmealymouthed\nmean/YRGJTPS\nmeander/JDSG\nmeaneing\nmeanie/MS\nmeaning/M\nmeaningful/YP\nmeaningfulness/SM\nmeaningless/PY\nmeaninglessness/SM\nmeanness/S\nmeans/M\nmeant/U\nmeantime/SM\nmeanwhile/S\nmeany's\nmeas/Y\nmeasle/SD\nmeasles/M\nmeasly/TR\nmeasurable/U\nmeasurably\nmeasure/BLMGRSD\nmeasured/Y\nmeasureless\nmeasurement/SM\nmeasurer/M\nmeasures/A\nmeasuring/A\nmeat/MS\nmeataxe\nmeatball/MS\nmeatiness/MS\nmeatless\nmeatloaf\nmeatloaves\nmeatpacking/S\nmeaty/RPT\nmecca/S\nmechanic/MS\nmechanical/YS\nmechanism/SM\nmechanist/M\nmechanistic\nmechanistically\nmechanization/SM\nmechanize/RSDZGB\nmechanized/U\nmechanizer/M\nmechanizes/U\nmechanochemically\nmed\nmedal/SGMD\nmedalist/MS\nmedallion/MS\nmeddle/GRSDZ\nmeddlesome\nmedia/SM\nmediaeval's\nmedial/AY\nmedials\nmedian/YMS\nmediate/PSDYVNGX\nmediateness/M\nmediation/ASM\nmediator/SM\nmedic/SM\nmedical/YS\nmedicament/MS\nmedicate/DSXNGV\nmedication/M\nmedicinal/SY\nmedicine/DSMG\nmedico/SM\nmedieval/YMS\nmedievalist/MS\nmediocre\nmediocrity/MS\nmeditate/NGVXDS\nmeditation/M\nmeditative/PY\nmeditativeness/M\nmedium/SM\nmediumistic\nmedley/SM\nmedulla/SM\nmeed/MS\nmeek/TPYR\nmeekness/MS\nmeerschaum/MS\nmeet/JGSYR\nmeeter/M\nmeeting/M\nmeetinghouse/S\nmega\nmegabit/MS\nmegabuck/S\nmegabyte/S\nmegacycle/MS\nmegadeath/M\nmegadeaths\nmegahertz/M\nmegalith/M\nmegalithic\nmegaliths\nmegalomania/SM\nmegalomaniac/SM\nmegalopolis/SM\nmegaphone/SDGM\nmegaton/MS\nmegavolt/M\nmegawatt/SM\nmegaword/S\nmegohm/MS\nmeioses\nmeiosis/M\nmeiotic\nmelamine/SM\nmelancholia/SM\nmelancholic/S\nmelancholy/MS\nmelange/S\nmelanin/MS\nmelanoma/SM\nmeld/SGD\nmeliorate/XSDVNG\nmelioration/M\nmellifluous/YP\nmellifluousness/SM\nmellow/TGRDYPS\nmellowness/MS\nmelodic/S\nmelodically\nmelodious/YP\nmelodiousness/S\nmelodrama/SM\nmelodramatic/S\nmelodramatically\nmelody/MS\nmelon/MS\nmelt/SAGD\nmeltdown/S\nmelter/M\nmelting/Y\nmember/DMS\nmembered/AE\nmembers/EA\nmembership/SM\nmembrane/MSD\nmembranous\nmemento/SM\nmemo/SM\nmemoir/MS\nmemorabilia\nmemorability/SM\nmemorable/P\nmemorableness/M\nmemorably\nmemorandum/SM\nmemorial/SY\nmemorialize/DSG\nmemorialized/U\nmemoriam\nmemorization/MS\nmemorize/RSDZG\nmemorized/U\nmemorizer/M\nmemorizes/A\nmemory/MS\nmemoryless\nmen/MS\nmenace/GSD\nmenacing/Y\nmenage/S\nmenagerie/SM\nmenarche/MS\nmend/RDSJGZ\nmendacious/PY\nmendaciousness/M\nmendacity/MS\nmendelevium/SM\nmender/M\nmendicancy/MS\nmendicant/S\nmending/M\nmenfolk/S\nmenhaden/M\nmenial/YS\nmeningeal\nmeninges\nmeningitides\nmeningitis/M\nmeninx\nmenisci\nmeniscus/M\nmenopausal\nmenopause/SM\nmenorah/M\nmenorahs\nmens/SDG\nmensch/S\nmenservants/M\nmenstrual\nmenstruate/NGDSX\nmenstruation/M\nmensurable/P\nmensuration/MS\nmenswear/M\nmental/Y\nmentalist/MS\nmentality/MS\nmenthol/SM\nmentholated\nmention/ZGBRDS\nmentionable/U\nmentioned/U\nmentioner/M\nmentor/DMSG\nmenu/SM\nmeow/DSG\nmer/TGDR\nmercantile\nmercenariness/M\nmercenary/SMP\nmercer/SM\nmercerize/SDG\nmerchandise/SRDJMZG\nmerchandiser/M\nmerchant/SBDMG\nmerchantability\nmerchantman/M\nmerchantmen\nmerciful/YP\nmercifully/U\nmercifulness/M\nmerciless/YP\nmercilessness/SM\nmercurial/SPY\nmercuric\nmercury/MS\nmercy/SM\nmere/YS\nmeretricious/YP\nmeretriciousness/SM\nmerganser/MS\nmerge/SRDGZ\nmerger/M\nmeridian/MS\nmeridional\nmeringue/MS\nmerino/MS\nmerit/SCGMD\nmerited/U\nmeritocracy/MS\nmeritocratic\nmeritocrats\nmeritorious/PY\nmeritoriousness/MS\nmerlin/M\nmermaid/MS\nmerman/M\nmermen\nmeromorphic\nmerrily\nmerriment/MS\nmerriness/S\nmerry/RPT\nmerrymaker/MS\nmerrymaking/SM\nmes/S\nmesa/SM\nmescal/SM\nmescaline/SM\nmesdames/M\nmesdemoiselles/M\nmesh/GMSD\nmeshed/U\nmesmeric\nmesmerism/SM\nmesmerize/SRDZG\nmesmerized/U\nmesmerizer/M\nmesomorph/M\nmesomorphs\nmeson/MS\nmesosphere/MS\nmesozoic\nmesquite/MS\nmess/GSDM\nmessage/SDMG\nmesseigneurs\nmessenger/GSMD\nmessiah\nmessiahs\nmessianic\nmessieurs/M\nmessily\nmessiness/MS\nmessmate/MS\nmessy/PRT\nmestizo/MS\nmet/U\nmeta\nmetabolic\nmetabolically\nmetabolism/MS\nmetabolite/SM\nmetabolize/GSD\nmetacarpal/S\nmetacarpi\nmetacarpus/M\nmetacircular\nmetacircularity\nmetal/SGMD\nmetalanguage/MS\nmetalization/SM\nmetalized\nmetallic/S\nmetalliferous\nmetallings\nmetallography/M\nmetalloid/M\nmetallurgic\nmetallurgical/Y\nmetallurgist/S\nmetallurgy/MS\nmetalsmith/MS\nmetalwork/RMJGSZ\nmetalworking/M\nmetamathematical\nmetamorphic\nmetamorphism/SM\nmetamorphose/GDS\nmetamorphosis/M\nmetaphor/MS\nmetaphoric\nmetaphorical/Y\nmetaphosphate/M\nmetaphysic/SM\nmetaphysical/Y\nmetastability/M\nmetastable\nmetastases\nmetastasis/M\nmetastasize/DSG\nmetastatic\nmetatarsal/S\nmetatarsi\nmetatarsus/M\nmetatheses\nmetathesis/M\nmetathesized\nmetathesizes\nmetathesizing\nmetavariable\nmete/ZDGSR\nmetempsychoses\nmetempsychosis/M\nmeteor/SM\nmeteoric\nmeteorically\nmeteorite/SM\nmeteoritic/S\nmeteoritics/M\nmeteoroid/SM\nmeteorologic\nmeteorological\nmeteorologist/S\nmeteorology/MS\nmeter/GDM\nmethadone/SM\nmethane/MS\nmethanol/SM\nmethinks\nmethionine/M\nmethod/MS\nmethodical/YP\nmethodicalness/SM\nmethodism\nmethodist/MS\nmethodological/Y\nmethodologists\nmethodology/MS\nmethought\nmethyl/SM\nmethylated\nmethylene/M\nmeticulous/YP\nmeticulousness/MS\nmetonymy/M\nmetric/SM\nmetrical/Y\nmetricate/SDNGX\nmetricize/GSD\nmetrics/M\nmetro/SM\nmetronome/MS\nmetropolis/SM\nmetropolitan/S\nmetropolitanization\nmets\nmettle/SDM\nmettlesome\nmew/SGD\nmewl/GSD\nmews/SM\nmezzanine/MS\nmezzo/S\nmfg\nmfr/S\nmg\nmgr\nmi/MNX\nmiasma/SM\nmiasmal\nmica/MS\nmice/M\nmicelles\nmickey/SM\nmicra's\nmicro/S\nmicroamp\nmicroanalysis/M\nmicroanalytic\nmicrobe/MS\nmicrobial\nmicrobicidal\nmicrobicide/M\nmicrobiological\nmicrobiologist/MS\nmicrobiology/SM\nmicrobrewery/S\nmicrochemistry/M\nmicrochip/S\nmicrocircuit/MS\nmicrocode/GSD\nmicrocomputer/MS\nmicrocosm/MS\nmicrocosmic\nmicrodensitometer\nmicrodot/MS\nmicroeconomic/S\nmicroeconomics/M\nmicroelectronic/S\nmicroelectronics/M\nmicrofiber/S\nmicrofiche/M\nmicrofilm/DRMSG\nmicrofossils\nmicrography/M\nmicrogroove/MS\nmicrohydrodynamics\nmicroinstruction/SM\nmicrojoule\nmicrolevel\nmicrolight/S\nmicromanage/GDSL\nmicromanagement/S\nmicrometeorite/MS\nmicrometeoritic\nmicrometer/SM\nmicron/MS\nmicroorganism/SM\nmicrophone/SGM\nmicroprocessing\nmicroprocessor/SM\nmicroprogram/SM\nmicroprogrammed\nmicroprogramming\nmicros/M\nmicroscope/SM\nmicroscopic\nmicroscopical/Y\nmicroscopy/MS\nmicrosecond/MS\nmicrosimulation/S\nmicrosomal\nmicrostore\nmicrosurgery/SM\nmicrovolt/SM\nmicrowave/BMGSD\nmicrowaveable\nmicroword/S\nmid/S\nmidair/MS\nmidas\nmidband/M\nmidday/MS\nmidden/SM\nmiddest\nmiddle/GJRSD\nmiddlebrow/SM\nmiddleman/M\nmiddlemen\nmiddlemost\nmiddleweight/SM\nmiddling/Y\nmiddy/SM\nmidfield/RM\nmidge/SM\nmidget/MS\nmidi/S\nmidland/MRS\nmidlife\nmidlives\nmidmorn/G\nmidmost/S\nmidnight/SYM\nmidpoint/MS\nmidrange\nmidrib/MS\nmidriff/MS\nmidscale\nmidsection/M\nmidship/S\nmidshipman/M\nmidshipmen\nmidspan\nmidst/SM\nmidstream/MS\nmidsummer/MS\nmidterm/MS\nmidtown/MS\nmidway/S\nmidweek/SYM\nmidwicket\nmidwife/SDMG\nmidwifery/SM\nmidwinter/YMS\nmidwives\nmidyear/MS\nmien/M\nmiff/GDS\nmight/S\nmightily\nmightiness/MS\nmightn't\nmighty/TPR\nmignon\nmignonette/SM\nmigraine/SM\nmigrant/MS\nmigrate/ASDG\nmigration/MS\nmigrative\nmigratory/S\nmikado/MS\nmike/DSMG\nmil/MRSZ\nmilady/MS\nmilch/M\nmild/STYRNP\nmildew/DMGS\nmildness/MS\nmile/SM\nmileage/SM\nmilepost/SM\nmiler/M\nmilestone/MS\nmilieu/SM\nmilitancy/MS\nmilitant/YPS\nmilitantness/M\nmilitarily\nmilitarism/SM\nmilitarist/MS\nmilitaristic\nmilitarization/SCM\nmilitarize/SDCG\nmilitary\nmilitate/SDG\nmilitia/SM\nmilitiaman/M\nmilitiamen\nmilk/GZSRDM\nmilker/M\nmilkiness/MS\nmilkmaid/SM\nmilkman/M\nmilkmen\nmilkshake/S\nmilksop/SM\nmilkweed/MS\nmilky/RPT\nmill/SGZMRD\nmillage/S\nmillenarian\nmillenarianism/M\nmillennial\nmillennialism\nmillennium/MS\nmillepede's\nmiller/M\nmillet/MS\nmilliamp\nmilliampere/S\nmilliard/MS\nmillibar/MS\nmillidegree/S\nmilligram/MS\nmillijoule/S\nmilliliter/MS\nmillimeter/SM\nmilliner/SM\nmillinery/MS\nmilling/M\nmillion/HDMS\nmillionaire/MS\nmillionth/M\nmillionths\nmillipede/SM\nmillisecond/MS\nmillivolt/SM\nmillivoltmeter/SM\nmilliwatt/S\nmillpond/MS\nmillrace/SM\nmillstone/SM\nmillstream/SM\nmillwright/MS\nmilquetoast/SM\nmilt/MDSG\nmime/DSRMG\nmimeograph/GMDS\nmimeographs\nmimer/M\nmimesis/M\nmimetic\nmimetically\nmimic/S\nmimicked\nmimicker/SM\nmimicking\nmimicry/MS\nmimosa/SM\nmin/DRZGJ\nminaret/MS\nminatory\nmince/SRDGZJ\nmincemeat/MS\nmincer/M\nmincing/Y\nmind's\nmind/ARDSZG\nmindbogglingly\nminded/P\nminder/M\nmindful/U\nmindfully\nmindfulness/MS\nmindless/YP\nmindlessness/SM\nmindset/S\nmine/SNX\nminefield/MS\nminer/M\nmineral/SM\nmineralization/C\nmineralized/U\nmineralogical\nmineralogist/SM\nmineralogy/MS\nmineshaft\nminestrone/MS\nminesweeper/MS\nmineworkers\nmingle/SDG\nmini/S\nminiature/GMSD\nminiaturist/SM\nminiaturization/MS\nminiaturize/SDG\nminibike/S\nminibus/SM\nminicab/M\nminicam/MS\nminicomputer/SM\nminidress/SM\nminify/GSD\nminim/SM\nminima's\nminimal/SY\nminimalism/S\nminimalist/MS\nminimalistic\nminimality\nminimax/M\nminimization/MS\nminimize/RSDZG\nminimized/U\nminimizer/M\nminimum/MS\nmining/M\nminion/M\nminiseries\nminiskirt/MS\nminister/MDGS\nministerial/Y\nministrant/S\nministration/SM\nministry/MS\nminivan/S\nminiver/M\nmink/SM\nminke\nminnesinger/MS\nminnow/SM\nminor/DMSG\nminority/MS\nminotaur/S\nminoxidil/S\nminster/SM\nminstrel/SM\nminstrelsy/MS\nmint/GZSMRD\nmintage/SM\nminter/M\nminty/RT\nminuend/SM\nminuet/SM\nminus/S\nminuscule/SM\nminute/RSDPMTYG\nminuteman\nminutemen\nminuteness/SM\nminutia/M\nminutiae\nminx/MS\nmiracle/MS\nmiraculous/PY\nmiraculousness/M\nmirage/GSDM\nmire/MGDS\nmirror/DMGS\nmirth/M\nmirthful/PY\nmirthfulness/SM\nmirthless/YP\nmirthlessness/M\nmirths\nmiry/RT\nmis/SRZ\nmisaddress/SDG\nmisadventure/SM\nmisalign/DSGL\nmisalignment/MS\nmisalliance/MS\nmisanalysed\nmisandrist\nmisandry\nmisanthrope/MS\nmisanthropic\nmisanthropically\nmisanthropist/S\nmisanthropy/SM\nmisapplier/M\nmisapply/GNXRSD\nmisapprehend/GDS\nmisapprehension/MS\nmisappropriate/GNXSD\nmisbegotten\nmisbehave/RSDG\nmisbehaver/M\nmisbehavior/SM\nmisbrand/DSG\nmisc\nmiscalculate/XGNSD\nmiscalculation/M\nmiscall/SDG\nmiscarriage/MS\nmiscarry/SDG\nmiscast/GS\nmiscegenation/SM\nmiscellanea\nmiscellaneous/PY\nmiscellany/MS\nmischance/MGSD\nmischief/MDGS\nmischievous/PY\nmischievousness/MS\nmiscibility/S\nmiscible/C\nmisclassification/M\nmisclassified\nmisclassifying\nmiscode/SDG\nmiscommunicate/NDS\nmiscomprehended\nmisconceive/GDS\nmisconception/MS\nmisconduct/GSMD\nmisconfiguration\nmisconstruction/MS\nmisconstrue/DSG\nmiscopying\nmiscount/DGS\nmiscreant/MS\nmiscue/MGSD\nmisdeal/SG\nmisdealt\nmisdeed/MS\nmisdemeanant/SM\nmisdemeanor/SM\nmisdiagnose/GSD\nmisdid\nmisdirect/GSD\nmisdirection/MS\nmisdirector/S\nmisdo/JG\nmisdoes\nmisdone\nmiser/KM\nmiserable/SP\nmiserableness/SM\nmiserably\nmiserliness/MS\nmiserly/P\nmisery/MS\nmises/KC\nmisfeasance/MS\nmisfeature/M\nmisfield\nmisfile/SDG\nmisfire/SDG\nmisfit/MS\nmisfitted\nmisfitting\nmisfortune/SM\nmisgauge/GDS\nmisgiving/MYS\nmisgovern/LDGS\nmisgovernment/S\nmisguidance/SM\nmisguide/DRSG\nmisguided/PY\nmisguidedness/M\nmisguider/M\nmishandle/SDG\nmishap/MS\nmishapped\nmishapping\nmishear/GS\nmisheard\nmishitting\nmishmash/SM\nmisidentification/M\nmisidentify/GNSD\nmisinform/GDS\nmisinformation/SM\nmisinterpret/RDSZG\nmisinterpretation/MS\nmisinterpreter/M\nmisjudge/DSG\nmisjudging/Y\nmisjudgment/MS\nmislabel/DSG\nmislaid\nmislay/GS\nmislead/GRJS\nmisleader/M\nmisleading/Y\nmisled\nmismanage/LGSD\nmismanagement/MS\nmismatch/GSD\nmisname/GSD\nmisnomer/GSMD\nmisogamist/MS\nmisogamy/MS\nmisogynist/MS\nmisogynistic\nmisogynous\nmisogyny/MS\nmisperceive/SD\nmisplace/GLDS\nmisplacement/MS\nmisplay/GSD\nmispositioned\nmisprint/SGDM\nmisprision/SM\nmispronounce/DSG\nmispronunciation/MS\nmisquotation/MS\nmisquote/GDS\nmisread/RSGJ\nmisreader/M\nmisrelated\nmisremember/DG\nmisreport/DGS\nmisrepresent/SDRG\nmisrepresentation/MS\nmisrepresenter/M\nmisroute/DS\nmisrule/SDG\nmiss/SDEGV\nmissal/ESM\nmisshape/DSG\nmisshapen/PY\nmisshapenness/SM\nmissile/MS\nmissilery/SM\nmission/AMS\nmissionary/MS\nmissioned\nmissioner/SM\nmissioning\nmissis's\nmissive/MS\nmisspeak/SG\nmisspecification\nmisspecified\nmisspell/SGJD\nmisspelling/M\nmisspend/GS\nmisspent\nmisspoke\nmisspoken\nmisstate/GLDRS\nmisstatement/MS\nmisstater/M\nmisstep/MS\nmisstepped\nmisstepping\nmissus/SM\nmist/MRDGZS\nmistakable/U\nmistake/BMGSR\nmistaken/Y\nmistaker/M\nmistaking/Y\nmister/GDM\nmistily\nmistime/GSD\nmistiness/S\nmistletoe/MS\nmistook\nmistral/MS\nmistranslated\nmistranslates\nmistranslating\nmistranslation/SM\nmistreat/DGSL\nmistreatment/SM\nmistress/MSY\nmistrial/SM\nmistrust/SRDG\nmistruster/M\nmistrustful/Y\nmisty/PRT\nmistype/SDGJ\nmisunderstand/JSRZG\nmisunderstander/M\nmisunderstanding/M\nmisunderstood\nmisuse/RSDMG\nmisuser/M\nmiswritten\nmite/SRMZ\nmiter/GRDM\nmiterer/M\nmitigate/XNGVDS\nmitigated/U\nmitigation/M\nmitoses\nmitosis/M\nmitotic\nmitt/XSMN\nmitten/M\nmitzvahs\nmix/AGSD\nmixable\nmixed/U\nmixer/SM\nmixture/SM\nmizzen/MS\nmizzenmast/SM\nmks\nml\nmm\nmnemonic/SM\nmnemonically\nmnemonics/M\nmo/CSK\nmoan/GSZRDM\nmoat/SMDG\nmob/MS\nmobbed\nmobber\nmobbing\nmobcap/SM\nmobile/S\nmobility/MS\nmobilizable\nmobilization/AMCS\nmobilize/CGDS\nmobilized/U\nmobilizer/MS\nmobilizes/A\nmobster/MS\nmoccasin/SM\nmocha/SM\nmock/GZSRD\nmockers/M\nmockery/MS\nmocking/Y\nmockingbird/MS\nmod/TSR\nmodal/Y\nmodality/MS\nmode/MS\nmodel/ZGSJMRD\nmodeled/A\nmodeler/M\nmodeling/M\nmodels/A\nmodem/SM\nmoderate/PNGDSXY\nmoderated/U\nmoderateness/SM\nmoderation/M\nmoderator/MS\nmodern/PTRYS\nmodernism/MS\nmodernist/S\nmodernistic\nmodernity/SM\nmodernization/MS\nmodernize/SRDGZ\nmodernized/U\nmodernizer/M\nmodernizes/U\nmodernness/SM\nmodest/TRY\nmodesty/MS\nmodicum/SM\nmodifiability/M\nmodifiable/U\nmodifiableness/M\nmodification/M\nmodified/U\nmodifier/M\nmodify/NGZXRSD\nmodish/YP\nmodishness/MS\nmodular/SY\nmodularity/SM\nmodularization\nmodularize/SDG\nmodulate/ADSNCG\nmodulation/CMS\nmodulator/ACSM\nmodule/SM\nmoduli\nmodulo\nmodulus/M\nmodus\nmogul/MS\nmohair/SM\nmoiety/MS\nmoil/SGD\nmoire/MS\nmoist/TXPRNY\nmoisten/ZGRD\nmoistener/M\nmoistness/MS\nmoisture/MS\nmoisturize/GZDRS\nmolal\nmolar/MS\nmolarity/SM\nmolasses/MS\nmold/MRDJSGZ\nmoldboard/SM\nmolder/DG\nmoldiness/SM\nmolding/M\nmoldy/PTR\nmole/MTS\nmolecular/Y\nmolecularity/SM\nmolecule/MS\nmolehill/SM\nmoleskin/MS\nmolest/RDZGS\nmolestation/SM\nmolested/U\nmolester/M\nmoll/MS\nmollification/M\nmollify/XSDGN\nmollusc's\nmollusk/S\nmolly/SM\nmollycoddle/SRDG\nmollycoddler/M\nmolt/RDNGZS\nmolter/M\nmolybdenite/M\nmolybdenum/MS\nmom/SM\nmoment/MYS\nmomenta\nmomentarily\nmomentariness/SM\nmomentary/P\nmomentous/YP\nmomentousness/MS\nmomentum/SM\nmomma/S\nmommy/SM\nmonad/SM\nmonadic\nmonarch/M\nmonarchic\nmonarchical\nmonarchism/MS\nmonarchist/MS\nmonarchistic\nmonarchs\nmonarchy/MS\nmonastery/MS\nmonastic/S\nmonastical/Y\nmonasticism/MS\nmonaural/Y\nmonetarily\nmonetarism/S\nmonetarist/MS\nmonetary\nmonetization/CMA\nmonetize/CGADS\nmoney/SMRD\nmoneybag/SM\nmoneychangers\nmoneyer/M\nmoneylender/SM\nmoneymaker/MS\nmoneymaking/MS\nmonger/SGDM\nmongolism/SM\nmongoloid/S\nmongoose/SM\nmongrel/SM\nmonies/M\nmoniker/MS\nmonism/MS\nmonist/SM\nmonition/SM\nmonitor/GSMD\nmonitored/U\nmonitory/S\nmonk/MS\nmonkey/SMDG\nmonkeyshine/S\nmonkish\nmonkshood/SM\nmono/MS\nmonochromatic\nmonochromator\nmonochrome/MS\nmonocle/SDM\nmonoclinic\nmonoclonal/S\nmonocotyledon/SM\nmonocotyledonous\nmonocular/SY\nmonodic\nmonodist/S\nmonody/MS\nmonogamist/MS\nmonogamous/PY\nmonogamy/MS\nmonogram/MS\nmonogrammed\nmonogramming\nmonograph/GMDS\nmonographs\nmonolingual/S\nmonolingualism\nmonolith/M\nmonolithic\nmonolithically\nmonoliths\nmonologist/S\nmonologue/GMSD\nmonomania/MS\nmonomaniac/MS\nmonomaniacal\nmonomer/SM\nmonomeric\nmonomial/SM\nmononuclear\nmononucleoses\nmononucleosis/M\nmonophonic\nmonoplane/MS\nmonopole/S\nmonopolist/MS\nmonopolistic\nmonopolization/MS\nmonopolize/GZDSR\nmonopolized/U\nmonopolizes/U\nmonopoly/MS\nmonorail/SM\nmonostable\nmonosyllabic\nmonosyllable/MS\nmonotheism/SM\nmonotheist/S\nmonotheistic\nmonotone/SDMG\nmonotonic\nmonotonically\nmonotonicity\nmonotonous/YP\nmonotonousness/MS\nmonotony/MS\nmonovalent\nmonoxide/SM\nmonseigneur\nmonsieur/M\nmonsignor/S\nmonsoon/MS\nmonsoonal\nmonster/SM\nmonstrance/ASM\nmonstrosity/SM\nmonstrous/YP\nmonstrousness/M\nmontage/SDMG\nmonth/MY\nmonthly/S\nmonths\nmonument/DMSG\nmonumental/Y\nmonumentality/M\nmoo/GSD\nmooch/ZSRDG\nmood/MS\nmoodily\nmoodiness/MS\nmoody/PTR\nmoon/GDMS\nmoonbeam/SM\nmoonless\nmoonlight/GZDRMS\nmoonlighting/M\nmoonlit\nmoonscape/MS\nmoonshine/SRZM\nmoonshiner/M\nmoonshot/MS\nmoonstone/SM\nmoonstruck\nmoonwalk/SDG\nmoor/GDMJS\nmooring/M\nmoorland/MS\nmoose/M\nmoot/RDGS\nmop/SZGMDR\nmope/S\nmoped/MS\nmoper/M\nmopey\nmopier\nmopiest\nmopish\nmopped\nmoppet/MS\nmopping\nmoraine/MS\nmoral/SMY\nmorale/MS\nmoralist/MS\nmoralistic\nmoralistically\nmorality/UMS\nmoralization/CS\nmoralize/CGDRSZ\nmoralled\nmoraller\nmoralling\nmorass/SM\nmoratorium/SM\nmoray/SM\nmorbid/YP\nmorbidity/SM\nmorbidness/S\nmordancy/MS\nmordant/GDYS\nmore/DSN\nmorel/SM\nmoreover\nmorgen/M\nmorgue/SM\nmoribund/Y\nmoribundity/M\nmorion/M\nmorn/SGJDM\nmorning/MY\nmorocco/SM\nmoron/SM\nmoronic\nmoronically\nmorose/YP\nmoroseness/MS\nmorph/GDJ\nmorpheme/DSMG\nmorphemic/S\nmorphia/S\nmorphine/MS\nmorphism/MS\nmorphologic\nmorphological/Y\nmorphology/MS\nmorphophonemic/S\nmorphophonemics/M\nmorphs\nmorris\nmorrow/MS\nmorsel/GMDS\nmortal/SY\nmortality/SM\nmortar/GSDM\nmortarboard/SM\nmortgage/MGDS\nmortgageable\nmortgagee/SM\nmortgagor/SM\nmortice's\nmortician/SM\nmortification/M\nmortified/Y\nmortifier/M\nmortify/DRSXGN\nmortise/MGSD\nmortuary/MS\nmos/S\nmosaic/MS\nmosaicked\nmosaicking\nmosey/SGD\nmosque/SM\nmosquito/M\nmosquitoes\nmoss/SDMG\nmossback/MS\nmossy/SRT\nmost/SY\nmot/MSV\nmote's\nmote/ASCNK\nmotel/MS\nmotet/SM\nmoth/ZMR\nmothball/DMGS\nmother/RDYMZG\nmotherboard/MS\nmotherfucker/MS!\nmotherfucking/!\nmotherhood/SM\nmothering/M\nmotherland/SM\nmotherless\nmotherliness/MS\nmotherly/P\nmoths\nmotif/MS\nmotile/S\nmotility/MS\nmotion's/ACK\nmotion/GRDMS\nmotional/K\nmotioner/M\nmotionless/YP\nmotionlessness/S\nmotions/K\nmotivate/XDSNGV\nmotivated/U\nmotivation/M\nmotivational/Y\nmotivator/S\nmotive/MGSD\nmotiveless\nmotley/S\nmotlier\nmotliest\nmotocross/SM\nmotor/DMSG\nmotorbike/SDGM\nmotorboat/MS\nmotorcade/MSDG\nmotorcar/MS\nmotorcycle/GMDS\nmotorcyclist/SM\nmotoring/M\nmotorist/SM\nmotorization/SM\nmotorize/DSG\nmotorized/U\nmotorman/M\nmotormen\nmotormouth\nmotormouths\nmotorway/SM\nmottle/GSRD\nmottler/M\nmotto/M\nmottoes\nmoue/DSMG\nmoulder/DSG\nmoult/GSD\nmound/GMDS\nmount/EGACD\nmountable\nmountain/SM\nmountaineer/JMDSG\nmountaineering/M\nmountainous/PY\nmountainousness/M\nmountainside/MS\nmountaintop/SM\nmountebank/SGMD\nmounted/U\nmounter/SM\nmounties\nmounting/MS\nmounts/AE\nmourn/ZGSJRD\nmourner/M\nmournful/YP\nmournfuller\nmournfullest\nmournfulness/S\nmourning/M\nmouse/SRDGMZ\nmouser/M\nmousetrap/SM\nmousetrapped\nmousetrapping\nmousiness/MS\nmousing/M\nmousse/MGSD\nmousy/PRT\nmouth/MSRDG\nmouthful/MS\nmouthiness/SM\nmouthorgan\nmouthpiece/SM\nmouths\nmouthwash/SM\nmouthwatering\nmouthy/PTR\nmouton/SM\nmovable/ASP\nmovableness/AM\nmove/ARSDGZB\nmoved/U\nmovement/SM\nmover/AM\nmovie/SM\nmoviegoer/S\nmoving/YS\nmow/SDRZG\nmower/M\nmowing/M\nmoxie/MS\nmozzarella/MS\nmp\nmpg\nmph\nms\nmt\nmtg\nmtge\nmu/M\nmuch/SP\nmuchness/M\nmucilage/MS\nmucilaginous\nmuck/GRDMS\nmucker/M\nmuckrake/ZMDRSG\nmuckraker/M\nmucky/RT\nmucosa/M\nmucous\nmucus/SM\nmud/MS\nmudded\nmuddily\nmuddiness/SM\nmudding\nmuddle/GRSDZ\nmuddlehead/SMD\nmuddleheaded/P\nmuddler/M\nmuddy/TPGRSD\nmudflat/S\nmudguard/SM\nmudlarks\nmudroom/S\nmudslide/S\nmudsling/JRGZ\nmudslinger/M\nmudslinging/M\nmuenster/MS\nmuesli/M\nmuezzin/MS\nmuff/GDMS\nmuffin/SM\nmuffle/ZRSDG\nmuffler/M\nmufti/MS\nmug/SM\nmugged\nmugger/SM\nmugginess/S\nmugging/S\nmuggy/RPT\nmugshot/S\nmugwump/MS\nmukluk/SM\nmulatto/M\nmulattoes\nmulberry/MS\nmulch/GMSD\nmulct/SDG\nmule/MGDS\nmuleskinner/S\nmuleteer/MS\nmulish/YP\nmulishness/MS\nmull/RDSG\nmullah/M\nmullahs\nmullein/MS\nmuller/M\nmullet/MS\nmulligan/SM\nmulligatawny/SM\nmullion/MDSG\nmulti\nmulticellular\nmultichannel/M\nmulticollinearity/M\nmulticolor/SDM\nmulticolumn\nmulticomponent\nmulticomputer/MS\nmulticultural\nmulticulturalism/S\nmultidimensional\nmultidimensionality\nmultidisciplinary\nmultifaceted\nmultifamily\nmultifarious/YP\nmultifariousness/SM\nmultifigure\nmultiform\nmultifunction/D\nmultilateral/Y\nmultilayer\nmultilevel/D\nmultilingual\nmultilingualism/S\nmultimedia/S\nmultimegaton/M\nmultimeter/M\nmultimillionaire/SM\nmultinational/S\nmultinomial/M\nmultiphase\nmultiple/SM\nmultiplet/SM\nmultiplex/GZMSRD\nmultiplexor's\nmultipliable\nmultiplicand/SM\nmultiplication/M\nmultiplicative/YS\nmultiplicity/MS\nmultiplier/M\nmultiply/ZNSRDXG\nmultiprocess/G\nmultiprocessor/MS\nmultiprogram\nmultiprogrammed\nmultiprogramming/MS\nmultipurpose\nmultiracial\nmultistage\nmultistory/S\nmultisyllabic\nmultitasking/S\nmultitude/MS\nmultitudinous/YP\nmultitudinousness/M\nmultiuser\nmultivalent\nmultivalued\nmultivariate\nmultiversity/M\nmultivitamin/S\nmum/MS\nmumble/ZJGRSD\nmumbler/M\nmumbletypeg/S\nmummed\nmummer/SM\nmummery/MS\nmummification/M\nmummify/XSDGN\nmumming\nmummy/GSDM\nmumps/M\nmun/S\nmunch/ZRSDG\nmuncher/M\nmunchies\nmundane/YSP\nmunge/JGZSRD\nmunicipal/YS\nmunicipality/SM\nmunificence/MS\nmunificent/Y\nmunition/SDG\nmuon/M\nmural/SM\nmuralist/SM\nmurder/GZRDMS\nmurderer/M\nmurderess/S\nmurderous/YP\nmurderousness/M\nmuriatic\nmurk/TRMS\nmurkily\nmurkiness/S\nmurky/RPT\nmurmur/RDMGZSJ\nmurmurer/M\nmurmuring/U\nmurmurous\nmurrain/SM\nmus/GJDSR\nmuscat/SM\nmuscatel/MS\nmuscle/SDMG\nmusclebound\nmuscovite/MS\nmuscular/Y\nmuscularity/SM\nmusculature/SM\nmuse\nmuser/M\nmusette/SM\nmuseum/MS\nmush/MSRDG\nmusher/M\nmushiness/MS\nmushroom/DMSG\nmushy/PTR\nmusic/SM\nmusical/YU\nmusicale/SM\nmusicality/SM\nmusicals\nmusician/MYS\nmusicianship/MS\nmusicked\nmusicking\nmusicological\nmusicologist/MS\nmusicology/MS\nmusing/Y\nmusk/GDMS\nmuskeg/SM\nmuskellunge/SM\nmusket/SM\nmusketeer/MS\nmusketry/MS\nmuskie/M\nmuskiness/MS\nmuskmelon/MS\nmuskox/N\nmuskrat/MS\nmusky/RSPT\nmuslin/MS\nmuss/SDG\nmussel/MS\nmussy/RT\nmust've\nmust/RDGZS\nmustache/DSM\nmustachio/MDS\nmustang/MS\nmustard/MS\nmuster/GD\nmustily\nmustiness/MS\nmustn't\nmusty/RPT\nmutability/SM\nmutable/P\nmutableness/M\nmutably\nmutagen/SM\nmutant/MS\nmutate/XVNGSD\nmutation/M\nmutational/Y\nmutator/S\nmute/PDSRBYTG\nmuted/Y\nmuteness/S\nmutilate/XDSNG\nmutilation/M\nmutilator/MS\nmutineer/SMDG\nmutinous/Y\nmutiny/MGSD\nmutt/ZSMR\nmutter/GZRDJ\nmutterer/M\nmutton/SM\nmuttonchops\nmutual/SY\nmutuality/S\nmuumuu/MS\nmuzak\nmuzzle/MGRSD\nmuzzled/U\nmuzzler/M\nmy/S\nmycologist/MS\nmycology/MS\nmyelitides\nmyelitis/M\nmyers\nmylar\nmyna/SM\nmyocardial\nmyocardium/M\nmyopia/MS\nmyopic/S\nmyopically\nmyriad/S\nmyrmidon/S\nmyrrh/M\nmyrrhs\nmyrtle/SM\nmys\nmyself\nmysterious/YP\nmysteriousness/MS\nmystery/MDSG\nmystic/SM\nmystical/Y\nmysticism/MS\nmystification/M\nmystifier/M\nmystify/CSDGNX\nmystifying/Y\nmystique/MS\nmyth/MS\nmythic\nmythical/Y\nmythographer/SM\nmythography/M\nmythological/Y\nmythologist/MS\nmythologize/CSDG\nmythology/SM\nmyths\nmtier/S\nmle/MS\nn's/CI\nn/T\nnab/S\nnabbed\nnabbing\nnabob/SM\nnacelle/SM\nnacho/S\nnacre/MS\nnacreous\nnadir/SM\nnae/VM\nnag/MS\nnagged\nnagger/S\nnagging/Y\nnaiad/SM\nnaifs\nnail/SGMRD\nnailbrush/SM\nnailer/M\nnaive/SRTYP\nnaivety/MS\nnaivet/SM\nnaked/TYRP\nnakedness/MS\nname's\nname/ADSG\nnameable/U\nnamed's\nnamed/U\nnamedrop\nnamedropping\nnameless/PY\nnamely\nnameplate/MS\nnamer/SM\nnamesake/SM\nnaming/M\nnanny/SDMG\nnanometer/MS\nnanosecond/SM\nnap/SM\nnapalm/MDGS\nnape/SM\nnaphtha/SM\nnaphthalene/MS\nnapkin/SM\nnapless\nnapoleon/MS\nnapped\nnapper/MS\nnapping\nnappy/TRSM\nnarc/DGS\nnarcissism/MS\nnarcissist/MS\nnarcissistic\nnarcissus/M\nnarcoleptic\nnarcoses\nnarcosis/M\nnarcotic/SM\nnarcotization/S\nnarcotize/GSD\nnark's\nnarrate/VGNSDX\nnarration/M\nnarrative/MYS\nnarratology\nnarrator/SM\nnarrow/RDYTGPS\nnarrowing/P\nnarrowness/SM\nnarwhal/MS\nnary\nnasal/YS\nnasality/MS\nnasalization/MS\nnasalize/GDS\nnascence/ASM\nnascent/A\nnastily\nnastiness/MS\nnasturtium/SM\nnasty/TRSP\nnatal\nnatalist\nnatality/M\nnatch/S\nnation/MS\nnational/YS\nnationalism/SM\nnationalist/MS\nnationalistic\nnationalistically\nnationality/MS\nnationalization/MS\nnationalize/CSDG\nnationalized/AU\nnationalizer/SM\nnationhood/SM\nnationwide\nnative/PYS\nnativeness/M\nnativity/MS\nnatl\nnatter/SGD\nnattily\nnattiness/SM\nnatty/TRP\nnatural/PUY\nnaturalism/MS\nnaturalist/MS\nnaturalistic\nnaturalization/SM\nnaturalize/GSD\nnaturalized/U\nnaturalness/US\nnaturals\nnature's\nnature/ASDCG\nnaturist\nnaught/MS\nnaughtily\nnaughtiness/SM\nnaughty/TPRS\nnausea/SM\nnauseate/DSG\nnauseating/Y\nnauseous/P\nnauseousness/SM\nnautical/Y\nnautilus/MS\nnaval/Y\nnave/SM\nnavel/MS\nnavigability/SM\nnavigable/P\nnavigableness/M\nnavigate/DSXNG\nnavigation/M\nnavigational\nnavigator/MS\nnavvy/M\nnavy/SM\nnay/MS\nnaysayer/S\nne'er\nneap/DGS\nnear/TYRDPSG\nnearby\nnearly/RT\nnearness/MS\nnearside/M\nnearsighted/YP\nnearsightedness/S\nneat/YRNTXPS\nneaten/DG\nneath\nneatness/MS\nnebula/M\nnebulae\nnebular\nnebulous/PY\nnebulousness/SM\nnecessaries\nnecessarily/U\nnecessary/U\nnecessitate/DSNGX\nnecessitation/M\nnecessitous\nnecessity/SM\nneck/GRDMJS\nneckband/M\nneckerchief/MS\nnecking/M\nnecklace/DSMG\nneckline/MS\nnecktie/MS\nnecrology/SM\nnecromancer/MS\nnecromancy/MS\nnecromantic\nnecrophilia/M\nnecrophiliac/S\nnecropolis/SM\nnecropsy/M\nnecroses\nnecrosis/M\nnecrotic\nnectar/SM\nnectarine/SM\nnectarous\nnectary/MS\nneed/YRDGS\nneeded/U\nneeder/M\nneedful/YSP\nneediness/MS\nneedle/GMZRSD\nneedlecraft/M\nneedlepoint/SM\nneedless/YP\nneedlessness/S\nneedlewoman/M\nneedlewomen\nneedlework/RMS\nneedn't\nneedy/TPR\nnefarious/YP\nnefariousness/MS\nneg/S\nnegate/XRSDVNG\nnegated/U\nnegater/M\nnegation/M\nnegative/PDSYG\nnegativeness/SM\nnegativism/MS\nnegativity/MS\nnegator/MS\nneglect/SDRG\nneglecter/M\nneglectful/YP\nneglectfulness/SM\nnegligee/SM\nnegligence/MS\nnegligent/Y\nnegligibility/M\nnegligible\nnegligibly\nnegotiability/MS\nnegotiable/A\nnegotiant/M\nnegotiate/ASDXGN\nnegotiation/MA\nnegotiator/MS\nnegritude/MS\nnegroid\nneigh/MDG\nneighbor/SMRDYZGJ\nneighbored/U\nneighborer/M\nneighborhood/SM\nneighborliness/UM\nneighborlinesses\nneighborly/UP\nneighs\nneither\nnelson/MS\nnematic\nnematode/SM\nnemeses\nnemesis\nneoclassic/M\nneoclassical\nneoclassicism/MS\nneocolonialism/MS\nneocortex/M\nneodymium/MS\nneolithic\nneologism/SM\nneomycin/M\nneon/DMS\nneonatal/Y\nneonate/MS\nneophyte/MS\nneoplasm/SM\nneoplastic\nneoprene/SM\nnepenthe/MS\nnephew/MS\nnephrite/SM\nnephritic\nnephritides\nnephritis/M\nnepotism/MS\nnepotist/S\nneptunium/MS\nnerd/S\nnerdy/RT\nnerve's\nnerve/UGSD\nnerveless/YP\nnervelessness/SM\nnerviness/SM\nnerving/M\nnervous/PY\nnervousness/SM\nnervy/TPR\nnest/RDGSBM\nnester/M\nnestle/RSDG\nnestler/M\nnestling/M\nnet/SM\nnetball/M\nnether\nnethermost\nnetherworld/S\nnett/JGRDS\nnetting/M\nnettle/MSDG\nnettlesome\nnetwork/SJMDG\nneural/Y\nneuralgia/MS\nneuralgic\nneurasthenia/MS\nneurasthenic/S\nneuritic/S\nneuritides\nneuritis/M\nneuroanatomy\nneurobiology/M\nneurological/Y\nneurologist/MS\nneurology/SM\nneuromuscular\nneuron/MS\nneuronal\nneurone/S\nneuropathology/M\nneurophysiology/M\nneuropsychiatric\nneuroses\nneurosis/M\nneurosurgeon/MS\nneurosurgery/SM\nneurotic/S\nneurotically\nneurotransmitter/S\nneut/ZR\nneuter/JZGRD\nneutral/PYS\nneutralise's\nneutralism/MS\nneutralist/S\nneutrality/MS\nneutralization/MS\nneutralize/GZSRD\nneutralized/U\nneutrino/MS\nneutron/MS\nnever\nnevermore\nnevertheless\nnevi\nnevus/M\nnew/SPTGDRY\nnewbie/S\nnewborn/S\nnewcomer/MS\nnewed/A\nnewel/MS\nnewer/A\nnewfangled\nnewfound\nnewfoundland\nnewish\nnewline/SM\nnewlywed/MS\nnewness/MS\nnews's\nnews/A\nnewsagent/MS\nnewsboy/SM\nnewscast/SRMGZ\nnewscaster/M\nnewscasting/M\nnewsdealer/MS\nnewsed\nnewses\nnewsflash/S\nnewsgirl/S\nnewsgroup/SM\nnewsing\nnewsletter/SM\nnewsman/M\nnewsmen\nnewspaper/SMGD\nnewspaperman/M\nnewspapermen\nnewspaperwoman/M\nnewspaperwomen\nnewsprint/MS\nnewsreader/MS\nnewsreel/SM\nnewsroom/S\nnewsstand/MS\nnewsweekly/S\nnewswire\nnewswoman/M\nnewswomen\nnewsworthiness/SM\nnewsworthy/RPT\nnewsy/TRS\nnewt/MS\nnewton/SM\nnext\nnexus/SM\nniacin/SM\nnib/SM\nnibbed\nnibbing\nnibble/RSDGZ\nnibbler/M\nnice/YTPR\nniceness/MS\nnicety/MS\nniche/SDGM\nnichrome\nnick/GZRDMS\nnickel/SGMD\nnickelodeon/SM\nnicker/GD\nnicknack's\nnickname/MGDRS\nnicknamer/M\nnicotine/MS\nniece/MS\nnifty/TRS\nniggard/SGMDY\nniggardliness/SM\nniggardly/P\nnigger/SGDM!\nniggle/RSDGZJ\nniggler/M\nniggling/Y\nnigh/RDGT\nnighs\nnight/SMYDZ\nnightcap/SM\nnightclothes\nnightclub/MS\nnightclubbed\nnightclubbing\nnightdress/MS\nnightfall/SM\nnightgown/MS\nnighthawk/MS\nnightie/MS\nnightingale/SM\nnightlife/MS\nnightlong\nnightmare/MS\nnightmarish/Y\nnightshade/SM\nnightshirt/MS\nnightspot/MS\nnightstand/SM\nnightstick/S\nnighttime/S\nnightwear/M\nnighty's\nnihilism/MS\nnihilist/MS\nnihilistic\nnil/MYS\nnilled\nnilling\nnilpotent\nnimbi\nnimble/TRP\nnimbleness/SM\nnimbly\nnimbus/DM\nnincompoop/MS\nnine/MS\nninefold\nninepence/M\nninepin/S\nninepins/M\nnineteen/SMH\nnineteenths\nninetieths\nninety/MHS\nninja/S\nninny/SM\nninth\nninths\nniobium/MS\nnip/S\nnipped\nnipper/DMGS\nnippiness/S\nnipping/Y\nnipple/GMSD\nnippy/TPR\nnirvana/MS\nnisei\nnit/ZSMR\nniter/M\nnitpick/DRSJZG\nnitrate/MGNXSD\nnitration/M\nnitric\nnitride/MGS\nnitriding/M\nnitrification/SM\nnitrite/MS\nnitrocellulose/MS\nnitrogen/SM\nnitrogenous\nnitroglycerin/MS\nnitrous\nnitwit/MS\nnix/GDSR\nnixer/M\nnm\nno/A\nnob/MY\nnobelium/MS\nnobility/MS\nnoble/TPSR\nnobleman/M\nnoblemen\nnobleness/SM\nnoblesse/M\nnoblewoman\nnoblewomen\nnobody/MS\nnocturnal/SY\nnocturne/SM\nnod/SM\nnodal/Y\nnodded\nnodding\nnoddle/MSDG\nnoddy/M\nnode/MS\nnodular\nnodule/SM\nnoel/S\nnoes/S\nnoggin/SM\nnohow\nnoise/GMSD\nnoiseless/YP\nnoiselessness/SM\nnoisemake/ZGR\nnoisemaker/M\nnoisily\nnoisiness/MS\nnoisome\nnoisy/TPR\nnomad/SM\nnomadic\nnomenclature/MS\nnominal/K\nnominalized\nnominally\nnominals\nnominate/CDSAXNG\nnomination/MAC\nnominative/SY\nnominator/CSM\nnominee/MS\nnon\nnonabrasive\nnonabsorbent/S\nnonacademic/S\nnonacceptance/MS\nnonacid/MS\nnonactive\nnonadaptive\nnonaddictive\nnonadhesive\nnonadjacent\nnonadjustable\nnonadministrative\nnonage/MS\nnonagenarian/MS\nnonaggression/SM\nnonagricultural\nnonalcoholic/S\nnonaligned\nnonalignment/SM\nnonallergic\nnonappearance/MS\nnonassignable\nnonathletic\nnonattendance/SM\nnonautomotive\nnonavailability/SM\nnonbasic\nnonbeliever/SM\nnonbelligerent/S\nnonblocking\nnonbreakable\nnonburnable\nnonbusiness\nnoncaloric\nnoncancerous\nnoncarbohydrate/M\nnonce/MS\nnonchalance/SM\nnonchalant/YP\nnonchargeable\nnonclerical/S\nnonclinical\nnoncollectable\nnoncom/MS\nnoncombatant/MS\nnoncombustible/S\nnoncommercial/S\nnoncommissioned\nnoncommittal/Y\nnoncommunicable\nnoncompeting\nnoncompetitive\nnoncompliance/MS\nnoncomplying/S\nnoncomprehending\nnonconducting\nnonconductor/MS\nnonconforming\nnonconformist/SM\nnonconformity/SM\nnonconsecutive\nnonconservative\nnonconstructive\nnoncontagious\nnoncontiguous\nnoncontinuous\nnoncontributing\nnoncontributory\nnoncontroversial\nnonconvertible\nnoncooperation/SM\nnoncorroding/S\nnoncorrosive\nnoncredit\nnoncriminal/S\nnoncritical\nnoncrystalline\nnoncumulative\nnoncustodial\nnoncyclic\nnondairy\nnondecreasing\nnondeductible\nnondelivery/MS\nnondemocratic\nnondenominational\nnondepartmental\nnondepreciating\nnondescript/YS\nnondestructive/Y\nnondetachable\nnondeterminacy\nnondeterminate/Y\nnondeterminism\nnondeterministic\nnondeterministically\nnondisciplinary\nnondisclosure/SM\nnondiscrimination/SM\nnondiscriminatory\nnondramatic\nnondrinker/SM\nnondrying\nnondurable\nnone/S\nnoneconomic\nnoneducational\nnoneffective/S\nnonelastic\nnonelectric/S\nnonelectrical\nnonemergency\nnonempty\nnonenforceable\nnonentity/MS\nnonequivalence/M\nnonequivalent/S\nnones/M\nnonessential/S\nnonesuch/SM\nnonetheless\nnonevent/MS\nnonexchangeable\nnonexclusive\nnonexempt\nnonexistence/MS\nnonexistent\nnonexplosive/S\nnonextensible\nnonfactual\nnonfading\nnonfat\nnonfatal\nnonfattening\nnonferrous\nnonfiction/SM\nnonfictional\nnonflammable\nnonflowering\nnonfluctuating\nnonflying\nnonfood/M\nnonfreezing\nnonfunctional\nnongovernmental\nnongranular\nnonhazardous\nnonhereditary\nnonhuman\nnonidentical\nnoninclusive\nnonindependent\nnonindustrial\nnoninfectious\nnoninflammatory\nnoninflationary\nnoninflected\nnonintellectual/S\nnoninteracting\nnoninterchangeable\nnoninterference/MS\nnonintervention/SM\nnonintoxicating\nnonintuitive\nnoninvasive\nnonionic\nnonirritating\nnonjudgmental\nnonjudicial\nnonlegal\nnonlethal\nnonlinear/Y\nnonlinearity/MS\nnonlinguistic\nnonliterary\nnonliving\nnonlocal\nnonmagical\nnonmagnetic\nnonmalignant\nnonmember/SM\nnonmetal/MS\nnonmetallic\nnonmigratory\nnonmilitant/S\nnonmilitary\nnonnarcotic/S\nnonnative/S\nnonnegative\nnonnegotiable\nnonnuclear\nnonnumerical/S\nnonobjective\nnonobligatory\nnonobservance/MS\nnonobservant\nnonoccupational\nnonoccurence\nnonofficial\nnonogenarian\nnonoperational\nnonoperative\nnonorthogonal\nnonorthogonality\nnonparallel/S\nnonparametric\nnonpareil/SM\nnonparticipant/SM\nnonparticipating\nnonpartisan/S\nnonpaying\nnonpayment/SM\nnonperformance/SM\nnonperforming\nnonperishable/S\nnonperson/S\nnonperturbing\nnonphysical/Y\nnonplus/S\nnonplussed\nnonplussing\nnonpoisonous\nnonpolitical\nnonpolluting\nnonporous\nnonpracticing\nnonprejudicial\nnonprescription\nnonprocedural/Y\nnonproductive\nnonprofessional/S\nnonprofit/SB\nnonprogrammable\nnonprogrammer\nnonproliferation/SM\nnonpublic\nnonpunishable\nnonracial\nnonradioactive\nnonrandom\nnonreactive\nnonreciprocal/S\nnonreciprocating\nnonrecognition/SM\nnonrecoverable\nnonrecurring\nnonredeemable\nnonreducing\nnonrefillable\nnonrefundable\nnonreligious\nnonrenewable\nnonrepresentational\nnonresident/SM\nnonresidential\nnonresidual\nnonresistance/SM\nnonresistant/S\nnonrespondent/S\nnonresponse\nnonrestrictive\nnonreturnable/S\nnonrhythmic\nnonrigid\nnonsalaried\nnonscheduled\nnonscientific\nnonscoring\nnonseasonal\nnonsectarian\nnonsecular\nnonsegregated\nnonsense/MS\nnonsensical/PY\nnonsensicalness/M\nnonsensitive\nnonsexist\nnonsexual\nnonsingular\nnonskid\nnonslip\nnonsmoker/SM\nnonsmoking\nnonsocial\nnonspeaking\nnonspecialist/MS\nnonspecializing\nnonspecific\nnonspiritual/S\nnonstaining\nnonstandard\nnonstarter/SM\nnonstick\nnonstop\nnonstrategic\nnonstriking\nnonstructural\nnonsuccessive\nnonsupervisory\nnonsupport/GS\nnonsurgical\nnonsustaining\nnonsympathizer/M\nnontarnishable\nnontaxable/S\nnontechnical/Y\nnontenured\nnonterminal/MS\nnonterminating\nnontermination/M\nnontheatrical\nnonthinking/S\nnonthreatening\nnontoxic\nnontraditional\nnontransferable\nnontransparent\nnontrivial\nnontropical\nnonuniform\nnonunion/S\nnonuser/SM\nnonvenomous\nnonverbal/Y\nnonveteran/MS\nnonviable\nnonviolence/SM\nnonviolent/Y\nnonvirulent\nnonvocal\nnonvocational\nnonvolatile\nnonvolunteer/S\nnonvoter/MS\nnonvoting\nnonwhite/SM\nnonworking\nnonyielding\nnonzero\nnoodle/GMSD\nnook/MS\nnoon/GDMS\nnoonday/MS\nnooning/M\nnoontide/MS\nnoontime/MS\nnoose/SDGM\nnope/S\nnor/H\nnoradrenalin\nnoradrenaline/M\nnorm/SMGD\nnormal/SY\nnormalcy/MS\nnormality/SM\nnormalization's\nnormalization/A\nnormalizations\nnormalize/SRDZGB\nnormalized/AU\nnormalizes/AU\nnormative/YP\nnormativeness/M\nnorth/MRGZ\nnorthbound\nnortheast/ZSMR\nnortheaster/YM\nnortheastern\nnortheastward/S\nnorther/MY\nnortherly/S\nnorthern/RYZS\nnorthernmost\nnorthing/M\nnorthland\nnorthmen\nnorths\nnorthward/S\nnorthwest/MRZS\nnorthwester/YM\nnorthwestern\nnorthwestward/S\nnos/GDS\nnose/M\nnosebag/M\nnosebleed/SM\nnosecone/S\nnosed/V\nnosedive/DSG\nnosegay/MS\nnosh/MSDG\nnosily\nnosiness/MS\nnosing/M\nnostalgia/SM\nnostalgic/S\nnostalgically\nnostril/SM\nnostrum/SM\nnosy/SRPMT\nnot/DRGB\nnotability/SM\nnotable/PS\nnotableness/M\nnotably\nnotarial\nnotarization/S\nnotarize/DSG\nnotary/MS\nnotate/VGNXSD\nnotation/CMSF\nnotational/CY\nnotative/CF\nnotch/MSDG\nnote's\nnote/CSDFG\nnotebook/MS\nnoted/YP\nnotedness/M\nnotepad/S\nnotepaper/MS\nnoteworthiness/SM\nnoteworthy/P\nnothing/PS\nnothingness/SM\nnotice/MSDG\nnoticeable/U\nnoticeably\nnoticeboard/S\nnoticed/U\nnotifiable\nnotification/M\nnotifier/M\nnotify/NGXSRDZ\nnotion/MS\nnotional/Y\nnotoriety/S\nnotorious/YP\nnotoriousness/M\nnotwithstanding\nnougat/MS\nnoun/SMK\nnourish/DRSGL\nnourished/U\nnourisher/M\nnourishment/SM\nnous/M\nnouveau\nnouvelle\nnova/MS\nnovae\nnovel/SM\nnovelette/SM\nnovelist/SM\nnovelization/S\nnovelize/GDS\nnovella/SM\nnovelty/MS\nnovena/SM\nnovene\nnovice/MS\nnovitiate/MS\nnow/S\nnowadays\nnoway/S\nnowhere/S\nnowise\nnoxious/PY\nnoxiousness/M\nnozzle/MS\nnroff/M\nnth\nnu/M\nnuance/SDM\nnub/MS\nnubbin/SM\nnubby/RT\nnubile\nnuclear/K\nnuclease/M\nnucleate/DSXNG\nnucleated/A\nnucleation/M\nnuclei/M\nnucleic\nnucleoli\nnucleolus/M\nnucleon/MS\nnucleotide/MS\nnucleus/M\nnuclide/M\nnude/CRS\nnudely\nnudeness/M\nnudest\nnudge/GSRD\nnudger/M\nnudism/MS\nnudist/MS\nnudity/MS\nnugatory\nnugget/SM\nnuisance/MS\nnuke/DSMG\nnull/DSG\nnullification/M\nnullifier/M\nnullify/RSDXGNZ\nnullity/SM\nnumb/SGZTYRDP\nnumber/RDMGJ\nnumbered/UA\nnumberer/M\nnumberless\nnumberplate/M\nnumbers/A\nnumbing/Y\nnumbness/MS\nnumbskull's\nnumerable/IC\nnumeracy/SI\nnumeral/YMS\nnumerate/SDNGX\nnumerates/I\nnumeration/M\nnumerator/MS\nnumeric/S\nnumerical/Y\nnumerological\nnumerologist/S\nnumerology/MS\nnumerous/YP\nnumerousness/M\nnuminous/S\nnumismatic/S\nnumismatics/M\nnumismatist/MS\nnumskull/SM\nnun/MS\nnuncio/SM\nnunnery/MS\nnuptial/S\nnurse/SRDJGMZ\nnursemaid/MS\nnurser/M\nnursery/MS\nnurseryman/M\nnurserymen\nnursling/M\nnurture/SRDGZM\nnurturer/M\nnus\nnut/MS\nnutate/NGSD\nnutation/M\nnutcrack/RZ\nnutcracker/M\nnuthatch/SM\nnutmeat/SM\nnutmeg/MS\nnutmegged\nnutmegging\nnutpick/MS\nnutria/SM\nnutrient/MS\nnutriment/MS\nnutrition/SM\nnutritional/Y\nnutritionist/MS\nnutritious/PY\nnutritiousness/MS\nnutritive/Y\nnutshell/MS\nnutted\nnuttiness/SM\nnutting\nnutty/TRP\nnuzzle/GZRSD\nnylon/SM\nnymph/M\nnymphet/MS\nnympholepsy/M\nnymphomania/MS\nnymphomaniac/S\nnymphs\nne\no\no'clock\no'er\no's\noaf/MS\noafish/PY\noafishness/S\noak/SMN\noakum/MS\noakwood\noar/GSMD\noarlock/MS\noarsman/M\noarsmen\noarswoman\noarswomen\noases\noasis/M\noat/SMNR\noatcake/MS\noater/M\noath/M\noaths\noatmeal/SM\nob\nobbligato/S\nobduracy/S\nobdurate/PDSYG\nobdurateness/S\nobedience/EMS\nobedient/EY\nobeisance/MS\nobeisant/Y\nobelisk/SM\nobese\nobesity/MS\nobey/EDRGS\nobeyer/EM\nobfuscate/SRDXGN\nobfuscation/M\nobfuscatory\nobi/MDGS\nobit/SMR\nobituary/SM\nobj\nobject/SGVMD\nobjectify/GSDXN\nobjection/SMB\nobjectionable/U\nobjectionableness/M\nobjectionably\nobjective/PYS\nobjectiveness/MS\nobjectivity/MS\nobjector/SM\nobjurgate/GNSDX\nobjurgation/M\noblate/NYPSX\noblation/M\nobligate/NGSDXY\nobligation/M\nobligational\nobligatorily\nobligatory\noblige/SRDG\nobliged/E\nobliger/M\nobliges/E\nobliging/PY\nobligingness/M\noblique/DSYGP\nobliqueness/S\nobliquity/MS\nobliterate/VNGSDX\nobliteration/M\nobliterative/Y\noblivion/MS\noblivious/YP\nobliviousness/MS\noblong/SYP\noblongness/M\nobloquies\nobloquy/M\nobnoxious/YP\nobnoxiousness/MS\noboe/SM\noboist/S\nobos\nobs\nobscene/RYT\nobscenity/MS\nobscurantism/MS\nobscurantist/MS\nobscuration\nobscure/YTPDSRGL\nobscureness/M\nobscurity/MS\nobsequies\nobsequious/YP\nobsequiousness/S\nobsequy\nobservability/M\nobservable/SU\nobservably\nobservance/MS\nobservant/U\nobservantly\nobservants\nobservation/MS\nobservational/Y\nobservatory/MS\nobserve/ZGDSRB\nobserved/U\nobserver/M\nobserving/Y\nobsess/GVDS\nobsession/MS\nobsessional\nobsessive/PYS\nobsessiveness/S\nobsidian/SM\nobsolesce/GSD\nobsolescence/S\nobsolescent/Y\nobsolete/GPDSY\nobsoleteness/M\nobstacle/SM\nobstetric/S\nobstetrical\nobstetrician/SM\nobstetrics/M\nobstinacy/SM\nobstinate/PY\nobstinateness/M\nobstreperous/PY\nobstreperousness/SM\nobstruct/RDVGS\nobstructed/U\nobstructer/M\nobstruction/SM\nobstructionism/SM\nobstructionist/MS\nobstructive/PSY\nobstructiveness/MS\nobtain/LSGDRB\nobtainable/U\nobtainably\nobtainment/S\nobtrude/DSRG\nobtruder/M\nobtrusion/S\nobtrusive/UPY\nobtrusiveness/MSU\nobtuse/PRTY\nobtuseness/S\nobverse/YS\nobviate/XGNDS\nobvious/YP\nobviousness/SM\nocarina/MS\noccasion/MDSJG\noccasional/Y\noccident/M\noccidental/SY\noccipital/Y\nocclude/GSD\nocclusion/MS\nocclusive/S\noccult/SRDYG\nocculter/M\noccultism/SM\noccupancy/SM\noccupant/MS\noccupation/SAM\noccupational/Y\noccupied/AU\noccupier/M\noccupies/A\noccupy/RSDZG\noccur/AS\noccurred/A\noccurrence/SM\noccurring/A\nocean/MS\noceanfront/MS\noceangoing\noceanic\noceanographer/SM\noceanographic\noceanography/SM\noceanology/MS\noceanside\nocelot/SM\nocher/DMGS\noctagon/SM\noctagonal/Y\noctahedral\noctahedron/M\noctal/S\noctane/MS\noctant/M\noctave/MS\noctavo/MS\noctennial\noctet/SM\noctile\noctillion/M\noctogenarian/MS\noctopi\noctopus/SM\noctoroon/M\nocular/S\noculist/SM\nodalisque/SM\nodd/TRYSPL\noddball/SM\noddity/MS\noddment/MS\noddness/MS\node/MDRS\nodious/PY\nodiousness/MS\nodium/MS\nodometer/SM\nodor/DMS\nodoriferous\nodorless\nodorous/YP\nodyssey/S\noedipal\noenology/MS\noenophile/S\noesophagi\noeuvre/SM\nof/K\noff/SZGDRJ\noffal/MS\noffbeat/MS\noffcuts\noffend/SZGDR\noffender/M\noffense/MSV\noffensive/YSP\noffensively/I\noffensiveness/MSI\noffer/RDJGZ\nofferer/M\noffering/M\noffertory/SM\noffhand/D\noffhanded/YP\noffhandedness/S\noffice/SRMZ\nofficeholder/SM\nofficemate/S\nofficer/GMD\nofficership/S\nofficial/PSYM\nofficialdom/SM\nofficialism/SM\nofficially/U\nofficiant/SM\nofficiate/XSDNG\nofficiation/M\nofficiator/MS\nofficio\nofficious/YP\nofficiousness/MS\noffing/M\noffish\noffload/GDS\noffprint/GSDM\nofframp\noffset/SM\noffsetting\noffshoot/MS\noffshore\noffside/RS\noffspring/M\noffstage/S\nofftrack\noft/NRT\noften/RT\noftentimes\nofttimes\nogive/M\nogle/ZGDSR\nogre/MS\nogreish\nogress/S\noh\nohm/SM\nohmic\nohmmeter/MS\noho/S\nohs\noil/MDRSZG\noilcloth/M\noilcloths\noiler/M\noilfield/MS\noiliness/SM\noilman/M\noilmen\noilseed/SM\noilskin/MS\noily/TPR\noink/GDS\nointment/SM\nokapi/SM\nokay/M\nokra/MS\nold/XTNRPS\nolden/DG\noldie/MS\noldish\noldness/S\noldster/SM\noleaginous\noleander/SM\nolefin/M\noleo/S\noleomargarine/SM\noles\nolfactory\noligarch/M\noligarchic\noligarchical\noligarchs\noligarchy/SM\noligopolistic\noligopoly/MS\nolive/MSR\nol\nom/XN\nombudsman/M\nombudsmen\nomega/MS\nomelet/SM\nomelette's\nomen/DMG\nomicron/MS\nominous/YP\nominousness/SM\nomission/MS\nomit/S\nomitted\nomitting\nomni/M\nomnibus/MS\nomnipotence/SM\nomnipotent/SY\nomnipresence/MS\nomnipresent/Y\nomniscience/SM\nomniscient/YS\nomnivore/MS\nomnivorous/PY\nomnivorousness/MS\noms\non/RY\nonanism/M\nonce/SR\noncer/M\noncogene/S\noncologist/S\noncology/SM\noncoming/S\none/NPMSX\noneiric\noneiric's\noneness/MS\noner/M\nonerous/YP\nonerousness/SM\noneself\nonetime\noneupmanship\nongoing/S\nonion/GDM\nonionskin/MS\nonlooker/MS\nonlooking\nonly/TP\nonomatopoeia/SM\nonomatopoeic\nonomatopoetic\nonrush/GMS\nons\nonset/SM\nonsetting\nonshore\nonside\nonslaught/MS\nonto\nontogeny/SM\nontological/Y\nontology/SM\nonus/SM\nonward/S\nonyx/MS\noodles\nooh/GD\noohs\noolitic\noops/S\nooze/GDS\noozy/RT\nop/XGDN\nopacity/SM\nopal/SM\nopalescence/S\nopalescent/Y\nopaque/GTPYRSD\nopaqueness/SM\nopcode/MS\nope/S\nopen/YRDJGZTP\nopencast\nopened/AU\nopener/M\nopenhanded/P\nopenhandedness/SM\nopenhearted\nopening/M\nopenness/S\nopens/A\nopenwork/MS\nopera/SM\noperable/I\noperand/SM\noperandi\noperant/YS\noperate/XNGVDS\noperatic/S\noperatically\noperation/M\noperational/Y\noperationalization/S\noperationalize/D\noperative/IP\noperatively\noperativeness/MI\noperatives\noperator/SM\noperetta/MS\nophthalmic/S\nophthalmologist/SM\nophthalmology/MS\nopiate/GMSD\nopine/XGNSD\nopinion/M\nopinionated/PY\nopinionatedness/M\nopioid\nopium/MS\nopossum/SM\nopp\nopponent/MS\nopportune/IY\nopportunism/SM\nopportunist/SM\nopportunistic\nopportunistically\nopportunity/MS\noppose/BRSDG\nopposed/U\nopposer/M\nopposite/SXYNP\noppositeness/M\nopposition/M\noppositional\noppress/DSGV\noppression/MS\noppressive/YP\noppressiveness/MS\noppressor/MS\nopprobrious/Y\nopprobrium/SM\nops\nopt/DSG\nopthalmic\nopthalmologic\nopthalmology\noptic/S\noptical/Y\noptician/SM\noptics/M\noptima\noptimal/Y\noptimality\noptimise's\noptimism/SM\noptimist/SM\noptimistic\noptimistically\noptimization/SM\noptimize/DRSZG\noptimized/U\noptimizer/M\noptimizes/U\noptimum/SM\noption/GDMS\noptional/YS\noptionality/M\noptoelectronic\noptometric\noptometrist/MS\noptometry/SM\nopulence/SM\nopulent/Y\nopus/SM\nor/MY\noracle/GMSD\noracular\noral/YS\norange/MS\norangeade/MS\norangery/SM\norangutan/MS\norate/SDGNX\noration/M\norator/MS\noratorical/Y\noratorio/MS\noratory/MS\norb/SMDG\norbicular\norbiculares\norbit/MRDGZS\norbital/MYS\norchard/SM\norchestra/MS\norchestral/Y\norchestrate/GNSDX\norchestrater's\norchestration/M\norchestrator/M\norchid/SM\nordain/SGLDR\nordainer/M\nordainment/MS\nordeal/SM\norder's/E\norder/AESGD\nordered/U\norderer\nordering/S\norderless\norderliness/SE\norderly/PS\nordinal/S\nordinance/MS\nordinarily\nordinariness/S\nordinary/RSPT\nordinate's\nordinate/I\nordinated\nordinates\nordinating\nordination/SM\nordnance/SM\nordure/MS\nore/NSM\noregano/SM\norgan/MS\norgandie's\norgandy/MS\norganelle/MS\norganic/S\norganically/I\norganism/MS\norganismic\norganist/MS\norganizable/UMS\norganization/MEAS\norganizational/MYS\norganize/AGZDRS\norganized/UE\norganizer/MA\norganizes/E\norganizing/E\norganometallic\norganza/SM\norgasm/GSMD\norgasmic\norgiastic\norgy/SM\noriel/MS\norient's\norient/GADES\norientable\noriental/SY\norientate/ESDXGN\norientated/A\norientates/A\norientation/AMES\norienteering/M\norienter\norifice/MS\norig\norigami/MS\norigin/MS\noriginal/US\noriginality/SM\noriginally\noriginate/VGNXSD\norigination/M\noriginative/Y\noriginator/SM\noriole/SM\norison/SM\normolu/SM\nornament/GSDM\nornamental/SY\nornamentation/SM\nornate/YP\nornateness/SM\norneriness/SM\nornery/PRT\nornithological\nornithologist/SM\nornithology/MS\norographic/M\norography/M\norotund\norotundity/MS\norphan/SGDM\norphanage/MS\norphanhood/M\norris/SM\nors\northodontia/S\northodontic/S\northodontics/M\northodontist/MS\northodox/YS\northodoxies\northodoxly/U\northodoxy's\northodoxy/U\northogonal/Y\northogonality/M\northogonalization/M\northogonalized\northographic\northographically\northography/MS\northonormal\northopedic/S\northopedics/M\northopedist/SM\northophosphate/MS\northorhombic\noscillate/SDXNG\noscillation/M\noscillator/SM\noscillatory\noscilloscope/SM\nosculate/XDSNG\nosculation/M\nosier/MS\nosmium/MS\nosmoses\nosmosis/M\nosmotic\nosprey/SM\nosseous/Y\nossification/M\nossify/NGSDX\nostensible\nostensibly\nostentation/MS\nostentatious/PY\nostentatiousness/M\nosteoarthritides\nosteoarthritis/M\nosteology/M\nosteopath/M\nosteopathic\nosteopaths\nosteopathy/MS\nosteoporoses\nosteoporosis/M\nostracise's\nostracism/MS\nostracize/GSD\nostrich/MS\nother/SMP\notherness/M\notherwise\notherworld/Y\notherworldly/P\notiose\notter/DMGS\nottoman/MS\noubliette/SM\nouch/SDG\nought/SGD\noughtn't\nounce/MS\nour/S\nourself\nourselves\noust/RDGZS\nouster/M\nout/PJZGSDR\noutage/MS\noutargue/GDS\noutback/MRS\noutbalance/GDS\noutbid/S\noutbidding\noutboard/S\noutboast/GSD\noutbound/S\noutbreak/SMG\noutbroke\noutbroken\noutbuilding/SM\noutburst/MGS\noutcast/GSM\noutclass/SDG\noutcome/SM\noutcrop/SM\noutcropped\noutcropping/S\noutcry/MSDG\noutdated/P\noutdid\noutdistance/GSD\noutdo/G\noutdoes\noutdone\noutdoor/S\noutdoorsy\noutdraw/GS\noutdrawn\noutdrew\noutermost\nouterwear/M\noutface/SDG\noutfall/MS\noutfield/RMSZ\noutfielder/M\noutfight/SG\noutfit/MS\noutfitted\noutfitter/MS\noutfitting\noutflank/SGD\noutflow/SMDG\noutfought\noutfox/GSD\noutgeneraled\noutgo/GJ\noutgoes\noutgoing/P\noutgrew\noutgrip\noutgrow/GSH\noutgrown\noutgrowth/M\noutgrowths\noutguess/SDG\nouthit/S\nouthitting\nouthouse/SM\nouting/M\noutlaid\noutland/ZR\noutlander/M\noutlandish/PY\noutlandishness/MS\noutlast/GSD\noutlaw/SDMG\noutlawry/M\noutlay/GSM\noutlet/SM\noutliers\noutline/SDGM\noutlive/GSD\noutlook/MDGS\noutlying\noutmaneuver/GSD\noutmatch/SDG\noutmigration\noutmoded\noutness/M\noutnumber/GDS\noutpaced\noutpatient/SM\noutperform/DGS\noutplacement/S\noutplay/GDS\noutpoint/GDS\noutpost/SM\noutpour/MJG\noutpouring/M\noutproduce/GSD\noutput/SM\noutputted\noutputting\noutrace/GSD\noutrage/GSDM\noutrageous/YP\noutrageousness/M\noutran\noutrank/GSD\noutreach/SDG\noutrider/MS\noutrigger/SM\noutright/Y\noutrun/S\noutrunning\noutr\noutscore/GDS\noutsell/GS\noutset/MS\noutsetting\noutshine/SG\noutshone\noutshout/GDS\noutside/ZSR\noutsider/PM\noutsize/S\noutskirt/SM\noutsmart/SDG\noutsold\noutsource/SDJG\noutspend/SG\noutspent\noutspoke\noutspoken/YP\noutspokenness/SM\noutspread/SG\noutstanding/Y\noutstate/NX\noutstation/M\noutstay/SDG\noutstretch/GSD\noutstrip/S\noutstripped\noutstripping\nouttake/S\noutvote/GSD\noutward/SYP\noutwardness/M\noutwear/SG\noutweigh/GD\noutweighs\noutwit/S\noutwitted\noutwitting\noutwore\noutwork/SMDG\noutworn\nouzo/SM\nova/M\noval/MYPS\novalness/M\novarian\novary/SM\novate/SDGNX\novation/GMD\noven/MS\novenbird/SM\nover/YGS\noverabundance/MS\noverabundant\noverachieve/SRDGZ\noveract/DGVS\noverage/S\noveraggressive\noverall/SM\noverallocation\noverambitious\noveranxious\noverarching\noverarm/GSD\noverate\noverattentive\noverawe/GDS\noverbalance/DSG\noverbear/GS\noverbearing/YP\noverbearingness/M\noverbid/S\noverbidding\noverbite/MS\noverblown\noverboard\noverbold\noverbook/SDG\noverbore\noverborne\noverbought\noverbuild/GS\noverbuilt\noverburden/SDG\noverburdening/Y\noverbuy/GS\novercame\novercapacity/M\novercapitalize/DSG\novercareful\novercast/GS\novercasting/M\novercautious\novercerebral\novercharge/DSG\novercloud/DSG\novercoat/SMG\novercoating/M\novercome/RSG\novercomer/M\novercommitment/S\novercompensate/XGNDS\novercompensation/M\novercomplexity/M\novercomplicated\noverconfidence/MS\noverconfident/Y\noverconscientious\noverconsumption/M\novercook/SDG\novercooled\novercorrection\novercritical\novercrowd/DGS\novercurious\noverdecorate/SDG\noverdependent\noverdetermined\noverdevelop/SDG\noverdid\noverdo/G\noverdoes\noverdone\noverdose/DSMG\noverdraft/SM\noverdraw/GS\noverdrawn\noverdress/GDS\noverdrew\noverdrive/GSM\noverdriven\noverdrove\noverdub/S\noverdubbed\noverdubbing\noverdue\novereager/PY\novereagerness/M\novereat/GNRS\novereater/M\novereducated\noveremotional\noveremphases\noveremphasis/M\noveremphasize/GZDSR\noverenthusiastic\noverestimate/DSXGN\noverestimation/M\noverexcite/DSG\noverexercise/SDG\noverexert/GDS\noverexertion/SM\noverexploitation\noverexploited\noverexpose/GDS\noverexposure/SM\noverextend/DSG\noverextension\noverfall/M\noverfed\noverfeed/GS\noverfill/GDS\noverfishing\noverflew\noverflight/SM\noverflow/DGS\noverflown\noverfly/GS\noverfond\noverfull\novergeneralize/GDS\novergenerous\novergraze/SDG\novergrew\noverground\novergrow/GSH\novergrown\novergrowth/M\novergrowths\noverhand/DGS\noverhang/GS\noverhasty\noverhaul/GRDJS\noverhead/S\noverhear/SRG\noverheard\noverhearer/M\noverheat/SGD\noverhung\noverincredulous\noverindulge/SDG\noverindulgence/SM\noverindulgent\noverinflated\noverjoy/SGD\noverkill/SDMG\noverladed\noverladen\noverlaid\noverlain\noverland/S\noverlap/MS\noverlapped\noverlapping\noverlarge\noverlay/GS\noverleaf\noverlie\noverload/SDG\noverlong\noverlook/DSG\noverlord/DMSG\noverloud\noverly/GRS\novermanning\novermaster/GSD\novermatching\novermodest\novermuch/S\novernice\novernight/SDRGZ\noveroptimism/SM\noveroptimistic\noverpaid\noverparticular\noverpass/GMSD\noverpay/LSG\noverpayment/M\noverplay/SGD\noverpopulate/DSNGX\noverpopulation/M\noverpopulous\noverpower/GSD\noverpowering/Y\noverpraise/DSG\noverprecise\noverpressure\noverprice/SDG\noverprint/DGS\noverproduce/SDG\noverproduction/S\noverprotect/GVDS\noverprotection/M\noverqualified\noverran\noverrate/DSG\noverreach/DSRG\noverreact/SGD\noverreaction/SM\noverred\noverrefined\noverrepresented\noverridden\noverride/RSG\noverrider/M\noverripe\noverrode\noverrule/GDS\noverrun/S\noverrunning\noversample/DG\noversaturate\noversaw\noversea/S\noversee/ZRS\noverseeing\noverseen\noverseer/M\noversell/SG\noversensitive/P\noversensitiveness/S\noversensitivity\noversexed\novershadow/GSD\novershoe/SM\novershoot/SG\novershot/S\noversight/SM\noversimple\noversimplification/M\noversimplify/GXNDS\noversize/GS\noversleep/GS\noverslept\noversoft/P\noversoftness/M\noversold\noverspecialization/MS\noverspecialize/GSD\noverspend/SG\noverspent\noverspill/DMSG\noverspread/SG\noverstaffed\noverstate/SDLG\noverstatement/SM\noverstay/GSD\noverstep/S\noverstepped\noverstepping\noverstimulate/DSG\noverstock/SGD\noverstraining\noverstressed\noverstretch/D\noverstrict\noverstrike/GS\noverstrung\noverstuffed\noversubscribe/SDG\noversubtle\noversupply/MDSG\noversuspicious\novert/PY\novertake/RSZG\novertaken\novertax/DSG\noverthrew\noverthrow/GS\noverthrown\novertightened\novertime/MGDS\novertire/DSG\novertone/MS\novertook\noverture/DSMG\noverturn/SDG\noveruse/DSG\novervalue/GSD\noverview/MS\noverweening\noverweight/GSD\noverwhelm/GDS\noverwhelming/Y\noverwinter/SDG\noverwork/GSD\noverwrap\noverwrite/SG\noverwritten\noverwrote\noverwrought\noverzealous/P\noverzealousness/M\noviduct/SM\noviform\noviparous\novoid/S\novular\novulate/GNXDS\novulatory\novule/MS\novum/MS\now/DYG\nowe/S\nowl/GSMDR\nowlet/SM\nowlish/PY\nowlishness/M\nown/EGDS\nowned/U\nowner/SM\nownership/MS\nox/MNS\noxalate/M\noxalic\noxaloacetic\noxblood/S\noxbow/SM\noxcart/MS\noxen/M\noxford/MS\noxidant/SM\noxidate/NVX\noxidation/M\noxidative/Y\noxide/SM\noxidization/MS\noxidize/JDRSGZ\noxidized/U\noxidizer/M\noxidizes/A\noxtail/M\noxyacetylene/MS\noxygen/MS\noxygenate/XSDMGN\noxygenation/M\noxyhydroxides\noxymora\noxymoron/M\noyster/GSDM\noystering/M\noz\nozone/SM\np's/A\np/XTGJ\npH/M\npa/MH\npablum/S\npabulum/SM\npace/DRSMZG\npacemaker/SM\npacer/M\npacesetter/MS\npacesetting\npachyderm/MS\npachysandra/MS\npacific\npacifically\npacification/M\npacifier/M\npacifism/MS\npacifist/MS\npacifistic\npacify/NRSDGXZ\npack/GZSJDRMB\npackage's\npackage/ARSDG\npackaged/U\npackager/S\npackages/U\npackaging/SM\npacked/AU\npacker/MUS\npacket/MSDG\npackhorse/M\npacking/M\npackinghouse/S\npacks/UA\npacksaddle/SM\npact/SM\npad/MS\npadded/U\npadding/SM\npaddle/MZGRSD\npaddler/M\npaddock/SDMG\npaddy/SM\npadlock/SGDM\npadre/MS\npaean/MS\npaediatrician/MS\npaediatrics/M\npaedophilia's\npaella/SM\npaeony/M\npagan/SM\npaganism/MS\npage/MZGDRS\npageant/SM\npageantry/SM\npageboy/SM\npaged/U\npageful\npager/M\npaginate/DSNGX\npagoda/MS\npaid/AU\npail/SM\npailful/SM\npain/GSDM\npainful/YP\npainfuller\npainfullest\npainfulness/MS\npainkiller/MS\npainkilling\npainless/YP\npainlessness/S\npainstaking/SY\npaint's\npaint/ADRZGS\npaintbox/M\npaintbrush/SM\npainted/U\npainter/YM\npainterly/P\npainting/SM\npaintwork\npair/JSDMG\npaired/UA\npairs/A\npairwise\npaisley/MS\npajama/MDS\npal/SJMDRYTG\npalace/MS\npaladin/MS\npalaeolithic\npalaeontologists\npalaeontology/M\npalanquin/MS\npalatability/M\npalatable/P\npalatableness/M\npalatal/YS\npalatalization/MS\npalatalize/SDG\npalate/BMS\npalatial/Y\npalatinate/SM\npalatine/S\npalaver/GSDM\npale/SPY\npaleface/SM\npaleness/S\npaleographer/SM\npaleography/SM\npaleolithic\npaleontologist/S\npaleontology/MS\npalette/MS\npalfrey/MS\npalimony/S\npalimpsest/MS\npalindrome/MS\npalindromic\npaling/M\npalisade/MGSD\npalish\npall/GSMD\npalladium/SM\npallbearer/SM\npallet/SMGD\npalletized\npalliate/SDVNGX\npalliation/M\npalliative/SY\npallid/PY\npallidness/MS\npallor/MS\npalm/GSMDR\npalmate\npalmer/M\npalmetto/MS\npalmist/MS\npalmistry/MS\npalmtop/S\npalmy/RT\npalomino/MS\npalpable\npalpably\npalpate/SDNGX\npalpation/M\npalpitate/NGXSD\npalpitation/M\npalsy/GSDM\npaltriness/SM\npaltry/TRP\npaludal\npampas/M\npamper/RDSG\npamperer/M\npamphlet/SM\npamphleteer/DMSG\npan/SMD\npanacea/MS\npanache/MS\npanama/S\npancake/MGSD\npanchromatic\npancreas/MS\npancreatic\npanda/SM\npandemic/S\npandemonium/SM\npander/ZGRDS\npane/KMS\npanegyric/SM\npanel/JSGDM\npaneling/M\npanelist/MS\npanelization\npanelized\npang/GDMS\npangolin/M\npanhandle/RSDGMZ\npanic/SM\npanicked\npanicking\npanicky/RT\npanier's\npanjandrum/M\npanned\npannier/SM\npanning\npanoply/MSD\npanorama/MS\npanoramic\npanpipes\npansy/SM\npant/GDS\npantaloons\npantheism/MS\npantheist/S\npantheistic\npantheon/MS\npanther/SM\npantie/SM\npantiled\npantograph/M\npantomime/SDGM\npantomimic\npantomimist/SM\npantry/SM\npantsuit/SM\npantyhose\npantyliner\npantywaist/SM\npap/SZMNR\npapa/MS\npapacy/SM\npapal/Y\npaparazzi\npapaw/SM\npapaya/MS\npaper/GJMRDZ\npaperback/GDMS\npaperboard/MS\npaperboy/SM\npaperer/M\npapergirl/SM\npaperhanger/SM\npaperhanging/SM\npaperiness/M\npaperless\npaperweight/MS\npaperwork/SM\npapery/P\npapilla/M\npapillae\npapillary\npapist/MS\npapoose/SM\npapped\npapping\npappy/RST\npaprika/MS\npapyri\npapyrus/M\npar/ZGSJBMDR\npara/MS\nparable/MGSD\nparabola/MS\nparabolic\nparaboloid/MS\nparaboloidal/M\nparacetamol/M\nparachute/RSDMG\nparachuter/M\nparachutist/MS\nparade/RSDMZG\nparader/M\nparadigm/SM\nparadigmatic\nparadisaic\nparadisaical\nparadise/MS\nparadox/MS\nparadoxic\nparadoxical/YP\nparadoxicalness/M\nparaffin/GSMD\nparagon/SGDM\nparagraph/MRDG\nparagrapher/M\nparagraphs\nparakeet/MS\nparalegal/S\nparalinguistic\nparallax/SM\nparallel/DSG\nparalleled/U\nparallelepiped/MS\nparallelism/SM\nparallelization/MS\nparallelize/ZGDSR\nparallelogram/MS\nparalysis/M\nparalytic/S\nparalytically\nparalyze/ZGDRS\nparalyzed/Y\nparalyzedly/S\nparalyzer/M\nparalyzing/Y\nparalyzingly/S\nparamagnet/M\nparamagnetic\nparamecia\nparamecium/M\nparamedic/MS\nparamedical/S\nparameter/SM\nparameterization/SM\nparameterize/BSDG\nparameterized/U\nparameterless\nparametric\nparametrically\nparametrization\nparametrize/DS\nparamilitary/S\nparamount/S\nparamour/MS\nparanoia/SM\nparanoiac/S\nparanoid/S\nparanormal/SY\nparapet/SMD\nparaphernalia\nparaphrase/GMSRD\nparaphraser/M\nparaplegia/MS\nparaplegic/S\nparaprofessional/SM\nparapsychologist/S\nparapsychology/MS\nparaquat/S\nparasite/SM\nparasitic/S\nparasitically\nparasitism/SM\nparasitologist/M\nparasitology/M\nparasol/SM\nparasympathetic/S\nparathion/SM\nparathyroid/S\nparatroop/RSZ\nparatrooper/M\nparatyphoid/S\nparboil/DSG\nparcel/SGMD\nparceled/U\nparceling/M\nparch/GSDL\nparchment/SM\npardon/ZBGRDS\npardonable/U\npardonableness/M\npardonably/U\npardoner/M\npare/S\nparegoric/SM\nparent/MDGJS\nparentage/MS\nparental/Y\nparenteral\nparentheses\nparenthesis/M\nparenthesize/GSD\nparenthetic\nparenthetical/Y\nparenthood/MS\npares/S\nparesis/M\nparfait/SM\npariah/M\npariahs\nparietal/S\nparimutuel/S\nparing/M\nparish/MS\nparishioner/SM\nparity/ESM\npark/GJZDRMS\nparka/MS\nparking/M\nparkish\nparkland/M\nparklike\nparkway/MS\nparlance/SM\nparlay/DGS\nparley/MDSG\nparliament/MS\nparliamentarian/SM\nparliamentary/U\nparlor/SM\nparlous\nparmigiana\nparochial/Y\nparochialism/SM\nparochiality\nparodied/U\nparodist/SM\nparody/SDGM\nparole/MSDG\nparolee/MS\nparoxysm/MS\nparoxysmal\nparquet/SMDG\nparquetry/SM\nparrakeet's\nparred\nparricidal\nparricide/MS\nparring\nparrot/GMDS\nparrotlike\nparry/GSD\npars/JDSRGZ\nparse\nparsec/SM\nparsed/U\nparser/M\nparsimonious/Y\nparsimony/SM\nparsley/MS\nparsnip/MS\nparson/MS\nparsonage/MS\npart's\npart/CDGS\npartake/ZGSR\npartaken\npartaker/M\nparter/S\nparterre/MS\nparthenogeneses\nparthenogenesis/M\npartial/SY\npartiality/MS\nparticipant/MS\nparticipate/NGVDSX\nparticipation/M\nparticipator/S\nparticipatory\nparticipial/Y\nparticiple/MS\nparticle/MS\nparticleboard/S\nparticolored\nparticular/SY\nparticularistic\nparticularity/SM\nparticularization/MS\nparticularize/GSD\nparticulate/S\nparting/MS\npartisan/SM\npartisanship/SM\npartition/AMRDGS\npartitioned/U\npartitioner/M\npartitive/S\npartizan's\npartly\npartner/DMGS\npartnership/SM\npartook\npartridge/MS\nparturition/SM\npartway\nparty/RSDMG\nparvenu/SM\npas/S\npascal/SM\npaschal/S\npasha/MS\npass/JGVBZDSR\npassably\npassage/MGSD\npassageway/MS\npassband\npassbook/MS\npassel/MS\npassenger/MYS\npasser/M\npasserby\npassersby\npassim\npassing/Y\npassion/SEM\npassionate/EYP\npassionated\npassionateness/EM\npassionates\npassionating\npassioned\npassionflower/MS\npassioning\npassionless\npassivated\npassive/SYP\npassiveness/S\npassivity/S\npasskey/SM\npassmark\npassover\npassport/SM\npassword/SDM\npass/M\npast's/A\npast/PGMDRS\npasta/MS\npaste/MS\npasteboard/SM\npasted/UA\npastel/MS\npastern/SM\npasteup\npasteurization/MS\npasteurize/RSDGZ\npasteurized/U\npasteurizer/M\npastiche/MS\npastille/SM\npastime/SM\npastiness/SM\npastor/GSDM\npastoral/SPY\npastoralization/M\npastorate/MS\npastrami/MS\npastry/SM\npasts/A\npasturage/SM\npasture/MGSRD\npasturer/M\npasty/PTRS\npat/MNDRS\npatch's\npatch/EGRSD\npatcher/EM\npatchily\npatchiness/S\npatchwork/RMSZ\npatchy/PRT\npate/SM\npatella/MS\npatellae\npaten/M\npatent/ZGMRDYSB\npatentee/SM\npater/M\npaterfamilias/SM\npaternal/Y\npaternalism/MS\npaternalist\npaternalistic\npaternity/SM\npaternoster/SM\npath/M\npathetic\npathetically\npathfinder/MS\npathless/P\npathname/SM\npathogen/SM\npathogenesis/M\npathogenic\npathologic\npathological/Y\npathologist/MS\npathology/SM\npathos/SM\npaths\npathway/MS\npatience/SM\npatient's/I\npatient/MRYTS\npatients/I\npatina/SM\npatine\npatio/MS\npatois/M\npatresfamilias\npatriarch/M\npatriarchal\npatriarchate/MS\npatriarchs\npatriarchy/MS\npatrician/MS\npatricide/MS\npatrimonial\npatrimony/SM\npatriot/SM\npatriotic/U\npatriotically\npatriotism/SM\npatristic/S\npatrol/MS\npatrolled\npatrolling\npatrolman/M\npatrolmen\npatrolwoman\npatrolwomen\npatron/YMS\npatronage/MS\npatroness/S\npatronization\npatronize/GZRSDJ\npatronized/U\npatronizer/M\npatronizes/A\npatronizing's/U\npatronizing/YM\npatronymic/S\npatronymically\npatroon/MS\npatsy/SM\npatted\npatten/MS\npatter/RDSGJ\npatterer/M\npattern/GSDM\npatternless\npatting\npatty/SM\npaucity/SM\npaunch/GMSD\npaunchiness/M\npaunchy/RTP\npauper/SGDM\npauperism/SM\npauperize/SDG\npause/DSG\npave/GDRSJL\npaved/UA\npavement/SGDM\npaver/M\npaves/A\npavilion/SMDG\npaving's\npaving/A\npaw/MDSG\npawl/SM\npawn/GSDRM\npawnbroker/SM\npawnbroking/S\npawner/M\npawnshop/MS\npawpaw's\npaxes\npay/AGSLB\npayable/S\npayback/S\npaycheck/SM\npayday/MS\npayed\npayee/SM\npayer/SM\npayload/SM\npaymaster/SM\npayment/ASM\npayoff/MS\npayola/MS\npayout/S\npayroll/MS\npayslip/S\npct\npd\npea/MS\npeace/GMDS\npeaceable/P\npeaceableness/M\npeaceably\npeaceful/PY\npeacefuller\npeacefullest\npeacefulness/S\npeacekeeping/S\npeacemaker/MS\npeacemaking/MS\npeacetime/MS\npeach/GSDM\npeachy/RT\npeacock/SGMD\npeafowl/SM\npeahen/MS\npeak/SGDM\npeaked/P\npeakiness/M\npeaky/P\npeal/MDSG\npealed/A\npeals/A\npeanut/SM\npear/SYM\npearl/SGRDM\npearler/M\npearly/TRS\npeartrees\npeasant/SM\npeasanthood\npeasantry/SM\npeashooter/MS\npeat/SM\npeats/A\npeaty/TR\npebble/MGSD\npebbling/M\npebbly/TR\npecan/SM\npeccadillo/M\npeccadilloes\npeccary/MS\npeck/GZSDRM\npecker/M\npectic\npectin/SM\npectoral/S\npeculate/NGDSX\npeculator/S\npeculiar/SY\npeculiarity/MS\npecuniary\npedagogic/S\npedagogical/Y\npedagogics/M\npedagogue/SDGM\npedagogy/MS\npedal/SGRDM\npedant/SM\npedantic\npedantically\npedantry/MS\npeddle/ZGRSD\npeddler/M\npederast/SM\npederasty/SM\npedestal/GDMS\npedestrian/MS\npedestrianization\npedestrianize/GSD\npediatric/S\npediatrician/SM\npedicab/SM\npedicure/DSMG\npedicurist/SM\npedigree/DSM\npediment/DMS\npedlar's\npedometer/MS\npedophile/S\npedophilia\npeduncle/MS\npee/ZDRS\npeeing\npeek/GSD\npeekaboo/SM\npeel/SJGZDR\npeeler/M\npeeling/M\npeen/GSDM\npeep/SGZDR\npeeper/M\npeephole/SM\npeepshow/MS\npeepy\npeer/DMG\npeerage/MS\npeeress/MS\npeerless/PY\npeerlessness/M\npeeve/GZMDS\npeevers/M\npeevish/YP\npeevishness/SM\npeewee/S\npeg/MS\npegboard/SM\npegged\npegging\npeignoir/SM\npejoration/SM\npejorative/SY\npeke/MS\npekingese\npekoe/SM\npelagic\npelf/SM\npelican/SM\npellagra/SM\npellet/SGMD\npellucid\npelt/GSDR\npelter/M\npelvic/S\npelvis/SM\npemmican/SM\npen/M\npenal/Y\npenalization/SM\npenalize/SDG\npenalized/U\npenalty/MS\npenance/SDMG\npence/M\npenchant/MS\npencil/SGJMD\npend/DCGS\npendant/SM\npendent/CS\npendulous\npendulum/MS\npenetrability/SM\npenetrable\npenetrate/SDVGNX\npenetrating/Y\npenetration/M\npenetrative/PY\npenetrativeness/M\npenetrator/MS\npenguin/MS\npenicillin/SM\npenile\npeninsula/SM\npeninsular\npenis/MS\npenitence/MS\npenitent/SY\npenitential/YS\npenitentiary/MS\npenknife/M\npenknives\npenlight/MS\npenman/M\npenmanship/MS\npenmen\npennant/SM\npenned\npenniless\npenning\npennis\npennon/SM\npenny/SM\npennyweight/SM\npennyworth/M\npenologist/MS\npenology/MS\npens/V\npension/ZGMRDBS\npensioner/M\npensive/PY\npensiveness/S\npent/AS\npentacle/MS\npentagon/SM\npentagonal/SY\npentagram/MS\npentameter/SM\npentathlete/S\npentathlon/MS\npentatonic\npentecostal\npenthouse/SDGM\npenuche/SM\npenultimate/SY\npenumbra/MS\npenumbrae\npenurious/YP\npenuriousness/MS\npenury/SM\npeon/MS\npeonage/MS\npeony/SM\npeople/SDMG\npep/SM\npepped\npepper/SGRDM\npeppercorn/MS\npepperer/M\npeppergrass/M\npeppermint/MS\npepperoni/S\npeppery\npeppiness/SM\npepping\npeppy/PRT\npepsin/SM\npeptic/S\npeptidase/SM\npeptide/SM\npeptizing\nper/K\nperadventure/S\nperambulate/DSNGX\nperambulation/M\nperambulator/MS\npercale/MS\nperceivably\nperceive/DRSZGB\nperceived/U\nperceiver/M\npercent/MS\npercentage/MS\npercentile/SM\npercept/VMS\nperceptible\nperceptibly\nperception/MS\nperceptional\nperceptive/YP\nperceptiveness/MS\nperceptual/Y\nperch/GSDM\nperchance\nperchlorate/M\nperchlorination\npercipience/MS\npercipient/S\npercolate/NGSDX\npercolation/M\npercolator/MS\npercuss/DSGV\npercussion/SAM\npercussionist/MS\npercussive/PY\npercussiveness/M\npercutaneous/Y\nperdition/MS\nperdurable\nperegrinate/XSDNG\nperegrination/M\nperegrine/S\nperemptorily\nperemptory/P\nperennial/SY\nperestroika/S\nperfect/DRYSTGVP\nperfecta/S\nperfecter/M\nperfectibility/MS\nperfectible\nperfection/MS\nperfectionism/MS\nperfectionist/MS\nperfective/PY\nperfectiveness/M\nperfectness/MS\nperfidious/YP\nperfidiousness/M\nperfidy/MS\nperforate/XSDGN\nperforated/U\nperforation/M\nperforce\nperform/SDRZGB\nperformance/MS\nperformed/U\nperformer/M\nperfume/ZMGSRD\nperfumer/M\nperfumery/SM\nperfunctorily\nperfunctoriness/M\nperfunctory/P\nperfused\nperfusion/M\npergola/SM\nperhaps/S\npericardia\npericardium/M\nperigee/SM\nperihelia\nperihelion/M\nperil/GSDM\nperilous/PY\nperilousness/M\nperimeter/MS\nperinatal\nperinea\nperineum/M\nperiod/MS\nperiodic\nperiodical/YMS\nperiodicity/MS\nperiodontal/Y\nperiodontics/M\nperiodontist/S\nperipatetic/S\nperipheral/SY\nperiphery/SM\nperiphrases\nperiphrasis/M\nperiphrastic\nperiscope/SDMG\nperish/BZGSRD\nperishable/SM\nperishing/Y\nperistalses\nperistalsis/M\nperistaltic\nperistyle/MS\nperitoneal\nperitoneum/SM\nperitonitis/MS\nperiwig/MS\nperiwigged\nperiwigging\nperiwinkle/SM\nperjure/SRDZG\nperjurer/M\nperjury/MS\nperk/GDS\nperkily\nperkiness/S\nperky/TRP\nperm/MDGS\npermafrost/MS\npermalloy/M\npermanence/SM\npermanency/MS\npermanent/YSP\npermanentness/M\npermeability/SM\npermeable/P\npermeableness/M\npermeate/NGVDSX\npermissibility/M\npermissible/P\npermissibleness/M\npermissibly\npermission/SM\npermissive/YP\npermissiveness/MS\npermit/SM\npermitted\npermitting\npermutation/MS\npermute/SDG\npernicious/PY\nperniciousness/MS\nperoration/SM\nperoxidase/M\nperoxide/MGDS\nperpend/DG\nperpendicular/SY\nperpendicularity/SM\nperpetrate/NGXSD\nperpetration/M\nperpetrator/SM\nperpetual/SY\nperpetuate/NGSDX\nperpetuation/M\nperpetuity/MS\nperplex/DSG\nperplexed/Y\nperplexity/MS\nperquisite/SM\npersecute/XVNGSD\npersecution/M\npersecutor/MS\npersecutory\nperseverance/MS\npersevere/GSD\npersevering/Y\npersiflage/MS\npersimmon/SM\npersist/DRSG\npersistence/SM\npersistent/Y\npersnickety\nperson's/U\nperson/BMS\npersona/M\npersonable/P\npersonableness/M\npersonae\npersonage/SM\npersonal/YS\npersonality/SM\npersonalization/CMS\npersonalize/CSDG\npersonalized/U\npersonalty/MS\npersonification/M\npersonifier/M\npersonify/XNGDRS\npersonnel/SM\npersons/U\nperspective/YMS\nperspex\nperspicacious/PY\nperspicaciousness/M\nperspicacity/S\nperspicuity/SM\nperspicuous/YP\nperspicuousness/M\nperspiration/MS\nperspire/DSG\npersuade/ZGDRSB\npersuaded/U\npersuader/M\npersuasion/SM\npersuasive/U\npersuasively\npersuasiveness/MS\npert/YRTSP\npertain/GSD\npertinacious/YP\npertinaciousness/M\npertinacity/MS\npertinence/S\npertinent/YS\npertness/MS\nperturb/GDS\nperturbation/MS\nperturbed/U\npertussis/SM\nperuke/SM\nperusal/SM\nperuse/RSDZG\nperuser/M\npervade/SDG\npervasion/M\npervasive/PY\npervasiveness/MS\nperverse/PXYNV\nperverseness/SM\nperversion/M\nperversity/MS\npervert/DRSG\nperverted/YP\nperverter/M\nperviousness\npeseta/SM\npeskily\npeskiness/S\npesky/RTP\npeso/MS\npessimal/Y\npessimism/SM\npessimist/SM\npessimistic\npessimistically\npest/RZSM\npester/DG\npesticide/MS\npestiferous\npestilence/SM\npestilent/Y\npestilential/Y\npestle/SDMG\npesto/S\npet/SMRZ\npetal/SDM\npetard/MS\npetcock/SM\npeter/GD\npethidine/M\npetiole/SM\npetite/XNPS\npetiteness/M\npetition's/A\npetition/GZMRD\npetitioner/M\npetitions/A\npetits\npetrel/SM\npetri\npetrifaction/SM\npetrify/NDSG\npetrochemical/SM\npetrodollar/MS\npetroglyph/M\npetrol/MS\npetrolatum/MS\npetroleum/MS\npetrolled\npetrolling\npetrologist/MS\npetrology/MS\npetted\npetter/MS\npetticoat/SMD\npettifog/S\npettifogged\npettifogger/SM\npettifogging\npettily\npettiness/S\npetting\npettis\npettish/YP\npettishness/M\npetty/PRST\npetulance/MS\npetulant/Y\npetunia/SM\npew/SM\npewee/MS\npewit/MS\npewter/SRM\npeyote/SM\npf\npfennig/SM\npg\nphaeton/MS\nphage/M\nphagocyte/SM\nphalanger/MS\nphalanges\nphalanx/SM\nphalli\nphallic\nphallus/M\nphantasm/SM\nphantasmagoria/SM\nphantasmal\nphantasy's\nphantom/MS\npharaoh\npharaohs\npharisaic\npharisee/S\npharmaceutic/S\npharmaceutical/SY\npharmaceutics/M\npharmacist/SM\npharmacological/Y\npharmacologist/SM\npharmacology/SM\npharmacopoeia/SM\npharmacy/SM\npharyngeal/S\npharynges\npharyngitides\npharyngitis/M\npharynx/M\nphase/DSRGZM\nphaseout/S\npheasant/SM\nphenacetin/MS\nphenobarbital/SM\nphenol/MS\nphenolic\nphenolphthalein/M\nphenomena/SM\nphenomenal/Y\nphenomenological/Y\nphenomenology/MS\nphenomenon/SM\nphenotype/MS\nphenyl/M\nphenylalanine/M\npheromone/MS\nphew/S\nphi/SM\nphial/MS\nphialled\nphialling\nphilander/SRDGZ\nphilanderer/M\nphilanthropic\nphilanthropically\nphilanthropist/MS\nphilanthropy/SM\nphilatelic\nphilatelist/MS\nphilately/SM\nphilharmonic/S\nphilippic/SM\nphilistine/S\nphilistinism/S\nphilodendron/MS\nphilological/Y\nphilologist/MS\nphilology/MS\nphilosopher/MS\nphilosophic\nphilosophical/Y\nphilosophize/ZDRSG\nphilosophized/U\nphilosophizer/M\nphilosophizes/U\nphilosophy/MS\nphilter/SGDM\nphiltre/DSMG\nphlebitides\nphlebitis/M\nphlegm/SM\nphlegmatic\nphlegmatically\nphloem/MS\nphlox/M\nphobia/SM\nphobic/S\nphoebe/SM\nphoenix/MS\nphone/DSGM\nphoneme/SM\nphonemic/S\nphonemically\nphonemics/M\nphonetic/S\nphonetically\nphonetician/SM\nphonetics/M\nphonic/S\nphonically\nphonics/M\nphoniness/MS\nphonograph/RM\nphonographer/M\nphonographic\nphonographs\nphonologic\nphonological/Y\nphonologist/MS\nphonology/MS\nphonon/M\nphony/PTRSDG\nphooey/S\nphosphatase/M\nphosphate/MS\nphosphide/M\nphosphine/MS\nphosphor/MS\nphosphoresce\nphosphorescence/SM\nphosphorescent/Y\nphosphoric\nphosphorous\nphosphorus/SM\nphoto/SGMD\nphotocell/MS\nphotochemical/Y\nphotochemistry/M\nphotocopier/M\nphotocopy/MRSDZG\nphotoelectric\nphotoelectrically\nphotoelectronic\nphotoelectrons\nphotoengrave/RSDJZG\nphotoengraver/M\nphotoengraving/M\nphotofinishing/MS\nphotogenic\nphotogenically\nphotograph's\nphotograph/AGD\nphotographer/SM\nphotographic\nphotographically\nphotographs/A\nphotography/MS\nphotojournalism/SM\nphotojournalist/SM\nphotoluminescence/M\nphotolysis/M\nphotolytic\nphotometer/SM\nphotometric\nphotometrically\nphotometry/M\nphotomicrograph/M\nphotomicrography/M\nphotomultiplier/M\nphoton/MS\nphotorealism\nphotosensitive\nphotosphere/M\nphotostatic\nphotosyntheses\nphotosynthesis/M\nphotosynthesize/DSG\nphotosynthetic\nphototypesetter\nphototypesetting/M\nphrasal\nphrase's\nphrase/AGDS\nphrasebook\nphrasemaking\nphraseology/MS\nphrasing/SM\nphrenological/Y\nphrenologist/MS\nphrenology/MS\nphyla/M\nphylactery/MS\nphylae\nphylogeny/MS\nphylum/M\nphys\nphysic/SM\nphysical/PYS\nphysicality/M\nphysician/SM\nphysicist/MS\nphysicked\nphysicking\nphysiochemical\nphysiognomy/SM\nphysiography/MS\nphysiologic\nphysiological/Y\nphysiologist/SM\nphysiology/MS\nphysiotherapist/MS\nphysiotherapy/SM\nphysique/MSD\nphytoplankton/M\npi/ZGDRH\npianism/M\npianissimo/S\npianist/SM\npianistic\npiano/SM\npianoforte/MS\npianola\npiaster/MS\npiazza/SM\npibroch/M\npibrochs\npica/SM\npicador/MS\npicaresque/S\npicayune/S\npiccalilli/MS\npiccolo/MS\npick/GZSJDR\npickaback's\npickax/GMSD\npickaxe's\npicker/MG\npickerel/MS\npicket/MSRDZG\npicketer/M\npickle/SDMG\npickoff/S\npickpocket/GSM\npickup/SM\npicky/RT\npicnic/SM\npicnicked\npicnicker/MS\npicnicking\npicofarad/MS\npicojoule\npicoseconds\npicot/DMGS\npictograph/M\npictographs\npictorial/PYS\npictorialness/M\npicture/MGSD\npicturesque/PY\npicturesqueness/SM\npiddle/GSD\npiddly\npidgin/SM\npie/MS\npiebald/S\npiece/GMDSR\npiecemeal\npiecer/M\npiecewise\npiecework/ZSMR\npieceworker/M\npiedmont\npieing\npier/M\npierce/RSDZGJ\npiercer/M\npiercing/Y\npiety/SM\npiezoelectric\npiezoelectricity/M\npiffle/MGSD\npig/MLS\npigeon/DMGS\npigeonhole/SDGM\npigged\npiggery/M\npigging\npiggish/YP\npiggishness/SM\npiggy/RSMT\npiggyback/MSDG\npigheaded/YP\npigheadedness/S\npiglet/MS\npigment/MDSG\npigmentation/MS\npigpen/SM\npigroot\npigskin/MS\npigsty/SM\npigswill/M\npigtail/SMD\npike/MZGDRS\npiker/M\npikestaff/MS\npilaf/MS\npilaster/SM\npilau's\npilchard/SM\npile/JDSMZG\npileup/MS\npilfer/ZGSRD\npilferage/SM\npilferer/M\npilgrim/MS\npilgrimage/DSGM\npiling/M\npill/GSMD\npillage/RSDZG\npillar/DMSG\npillbox/MS\npillion/DMGS\npillory/MSDG\npillow/GDMS\npillowcase/SM\npillowslip/S\npilot/DMGS\npilothouse/SM\npiloting/M\npimento/MS\npimiento/SM\npimp/GSMYD\npimpernel/SM\npimple/SDM\npimplike\npimply/TRM\npin's\npin/US\npinafore/MS\npinball/MS\npincer/GSD\npinch/GRSD\npincher/M\npincushion/SM\npine/MNGXDS\npineapple/MS\npined/A\npines/A\npinfeather/SM\nping/GDRM\npinhead/SMD\npinheaded/P\npinhole/SM\npining/A\npinion/DMG\npink/GTYDRMPS\npinkeye/MS\npinkie/SM\npinkish/P\npinkness/S\npinko/MS\npinky's\npinnacle/MGSD\npinnate\npinned/U\npinning/S\npinochle/SM\npinpoint/SDG\npinprick/MDSG\npinsetter/SM\npinstripe/SDM\npint/MRS\npintail/SM\npinto/S\npinup/MS\npinwheel/DMGS\npiny/RT\npinyin\npion/M\npioneer/SDMG\npious/YP\npiousness/MS\npip/JSZMGDR\npipe/MS\npipeline/DSMG\npiper/M\npipet's\npipette/MGSD\npipework\npiping/YM\npipit/MS\npipped\npippin/SM\npipping\npipsqueak/SM\npiquancy/MS\npiquant/PY\npiquantness/M\npique/GMDS\npiracy/MS\npiranha/SM\npirate/MGSD\npiratical/Y\npirogi\npirogies\npirouette/MGSD\npis\npiscatorial\npismire/SM\npiss/DSRG!\npistachio/MS\npiste/SM\npistil/MS\npistillate\npistol/SMGD\npistole/M\npistoleers\npiston/SM\npit/MS\npita/SM\npitapat/S\npitapatted\npitapatting\npitch/RSDZG\npitchblende/SM\npitcher/M\npitchfork/GDMS\npitching/M\npitchman/M\npitchmen\npitchstone/M\npiteous/YP\npiteousness/SM\npitfall/SM\npith/MGDS\npithily\npithiness/SM\npiths\npithy/RTP\npitiable/P\npitiableness/M\npitiably\npitier/M\npitiful/PY\npitifuller\npitifullest\npitifulness/M\npitiless/PY\npitilessness/SM\npitman/M\npiton/SM\npittance/SM\npitted\npitting\npituitary/SM\npity/ZDSRMG\npitying/Y\npivot/DMSG\npivotal/Y\npivoting/M\npix/DSG\npixel/SM\npixie/MS\npixiness\npixmap/SM\npizazz/S\npizza/SM\npizzeria/SM\npizzicati\npizzicato\npiata/S\npion/S\npj's\npk\npkg\npkt\npkwy\npl\nplacard/DSMG\nplacate/NGVXDRS\nplacatory\nplace/DSRJLGZM\nplaceable/A\nplacebo/SM\nplaced/EAU\nplaceholder/S\nplacekick/DGS\nplaceless/Y\nplacement/AMES\nplacenta/SM\nplacental/S\nplacer/EM\nplaces/EA\nplacid/PY\nplacidity/SM\nplacidness/M\nplacing/AE\nplacket/SM\nplagiarism/MS\nplagiarist/MS\nplagiarize/GZDSR\nplagiary/SM\nplague/MGRSD\nplagued/U\nplaguer/M\nplaice/M\nplaid/DMSG\nplain/SPTGRDY\nplainclothes\nplainclothesman\nplainclothesmen\nplainness/MS\nplainsman/M\nplainsmen\nplainsong/SM\nplainspoken\nplaint/VMS\nplaintiff/MS\nplaintive/YP\nplaintiveness/M\nplait/SRDMG\nplaiting/M\nplan/DRMSGZ\nplanar\nplanarity\nplane's\nplane/SCGD\nplaneload\nplaner/M\nplanet/MS\nplanetarium/MS\nplanetary\nplanetesimal/M\nplanetoid/SM\nplangency/S\nplangent\nplank/SJMDG\nplanking/M\nplankton/MS\nplanned/U\nplanner/SM\nplanning\nplanoconcave\nplanoconvex\nplant's\nplant/SADG\nplantain/MS\nplantar\nplantation/MS\nplanter/MS\nplanting/S\nplantlike\nplaque/MS\nplash/GSDM\nplasm/M\nplasma/MS\nplasmid/S\nplaster/MDRSZG\nplasterboard/MS\nplasterer/M\nplastering/M\nplasterwork/M\nplastic/MYS\nplastically\nplasticine\nplasticity/SM\nplasticize/GDS\nplat/JDNRSGXZ\nplate/SM\nplateau/GDMS\nplateful/S\nplatelet/SM\nplaten/M\nplater/M\nplatform/SGDM\nplating/M\nplatinize/GSD\nplatinum/MS\nplatitude/SM\nplatitudinous/Y\nplatonic\nplatoon/MDSG\nplatted\nplatter/MS\nplatting\nplaty/TR\nplatypus/MS\nplatys\nplaudit/MS\nplausibility/S\nplausible/P\nplausibly\nplay/DRSEBG\nplayability/U\nplayable/U\nplayact/SJDG\nplayacting/M\nplayback/MS\nplaybill/SM\nplayboy/SM\nplayed/A\nplayer's/E\nplayer/SM\nplayfellow/S\nplayful/PY\nplayfulness/MS\nplaygirl/SM\nplaygoer/MS\nplayground/MS\nplaygroup/S\nplayhouse/SM\nplaying/S\nplaymate/MS\nplayoff/S\nplaypen/SM\nplayroom/SM\nplays/A\nplaything/MS\nplaytime/SM\nplaywright/SM\nplaywriting/M\nplaza/SM\nplea/SM\nplead/ZGJRDS\npleader/MA\npleading/MY\npleas/RSDJG\npleasant/UYP\npleasanter\npleasantest\npleasantness/SMU\npleasantry/MS\nplease/Y\npleased/EU\npleaser/M\npleases/E\npleasing/YP\npleasingness/M\npleasurable/P\npleasurableness/M\npleasurably\npleasure's/E\npleasure/MGBDS\npleasureful\npleasures/E\npleat/RDMGS\npleater/M\nplebe/MS\nplebeian/SY\nplebiscite/SM\nplectra\nplectrum/SM\npledge/RSDMG\npledger/M\nplenary/S\nplenipotentiary/S\nplenitude/MS\nplenteous/PY\nplenteousness/M\nplentiful/YP\nplentifulness/M\nplenty/SM\nplenum/M\npleonasm/MS\nplethora/SM\npleura/M\npleurae\npleural\npleurisy/SM\nplexus/SM\npliability/MS\npliable/P\npliableness/M\npliancy/MS\npliant/YP\npliantness/M\nplication/MA\nplier/MA\nplight/GMDRS\nplimsolls\nplink/GRDS\nplinker/M\nplinth/M\nplinths\nplod/S\nplodded\nplodder/SM\nplodding/SY\nplop/SM\nplopped\nplopping\nplosive\nplot/SM\nplotted/A\nplotter/MDSG\nplotting\nplover/MS\nplow/SGZDRM\nplowed/U\nplower/M\nplowman/M\nplowmen\nplowshare/MS\nploy's\nploy/SCDG\npluck/SGRD\nplucker/M\npluckily\npluckiness/SM\nplucky/TPR\nplug's\nplug/US\npluggable\nplugged/UA\nplugging/AU\nplughole\nplum/SMDG\nplumage/DSM\nplumb/JSZGMRD\nplumbago/M\nplumbed/U\nplumber/M\nplumbing/M\nplume/SM\nplummer\nplummest\nplummet/DSG\nplummy\nplump/RDNYSTGP\nplumper/M\nplumpness/S\nplumy/TR\nplunder/GDRSZ\nplunge/RSDZG\nplunger/M\nplunk/ZGSRD\nplunker/M\npluperfect/S\nplural/SY\npluralism/MS\npluralist/S\npluralistic\nplurality/SM\npluralization/MS\npluralize/GZRSD\npluralizer/M\nplus/S\nplush/RSYMTP\nplushness/MS\nplushy/RPT\nplussed\nplussing\nplutocracy/MS\nplutocrat/SM\nplutocratic\nplutonium/SM\npluvial/S\nply/AZNGRSD\nplywood/MS\npm\npneumatic/S\npneumatically\npneumatics/M\npneumonia/MS\npoach/ZGSRD\npoacher/M\npock/GDMS\npocket/MSRDG\npocketbook/SM\npocketful/SM\npocketing/M\npocketknife/M\npocketknives\npockmark/MDSG\npod/SM\npodded\npodding\npodge/ZR\npodiatrist/MS\npodiatry/MS\npodium/MS\npoem/MS\npoesy/GSDM\npoet/MS\npoetaster/MS\npoetess/MS\npoetic/S\npoetical/U\npoetically\npoeticalness\npoetics/M\npoetry/SM\npogo\npogrom/GMDS\npoi/SM\npoignancy/MS\npoignant/Y\npoinciana/SM\npoinsettia/SM\npoint/RDMZGS\npointblank\npointed/PY\npointedness/M\npointer/M\npointillism/SM\npointillist/SM\npointing/M\npointless/YP\npointlessness/SM\npointy/TR\npois/GDS\npoise/M\npoison/RDMZGSJ\npoisoner/M\npoisoning/M\npoisonous/PY\npoke/DRSZG\npoker/M\npokerface/D\npoky/SRT\npol/GMDRS\npolar/S\npolarimeter/SM\npolarimetry\npolariscope/M\npolarity/MS\npolarization/CMS\npolarize/RSDZG\npolarized/UC\npolarizes/C\npolarizing/C\npolarogram/SM\npolarograph\npolarography/M\npole/MS\npolecat/SM\npolemic/S\npolemical/Y\npolemicist/S\npolemics/M\npoler/M\npolestar/S\npoleward/S\npolice/MSDG\npoliceman/M\npolicemen/M\npolicewoman/M\npolicewomen\npolicy/SM\npolicyholder/MS\npolicymaker/S\npolicymaking\npolio/SM\npoliomyelitides\npoliomyelitis/M\npolis/M\npolish/RSDZGJ\npolished/U\npolisher/M\npolitburo/S\npolite/PRTY\npoliteness/MS\npolitesse/SM\npolitic/S\npolitical/U\npolitically\npolitician/MS\npoliticization/S\npoliticize/CSDG\npoliticked\npoliticking/SM\npolitico/SM\npolitics/M\npolity/MS\npolka/SDMG\npoll/MDNRSGX\npollack/SM\npolled/U\npollen/GDM\npollinate/XSDGN\npollination/M\npollinator/MS\npolliwog/SM\npollock's\npollster/MS\npollutant/MS\npollute/RSDXZVNG\npolluted/U\npolluter/M\npollution/M\npollywog's\npolo/MS\npolonaise/MS\npolonium/MS\npoltergeist/SM\npoltroon/MS\npolyandrous\npolyandry/MS\npolyatomic\npolybutene/MS\npolycarbonate\npolychemicals\npolychrome\npolyclinic/MS\npolycrystalline\npolyelectrolytes\npolyester/SM\npolyether/S\npolyethylene/SM\npolygamist/MS\npolygamous/Y\npolygamy/MS\npolyglot/S\npolygon/MS\npolygonal/Y\npolygraph/MDG\npolygraphs\npolygynous\npolyhedral\npolyhedron/MS\npolyisobutylene\npolyisocyanates\npolymath/M\npolymaths\npolymer/MS\npolymerase/S\npolymeric\npolymerization/SM\npolymerize/SDG\npolymorph/M\npolymorphic\npolymorphism/MS\npolymyositis\npolynomial/YMS\npolyp/MS\npolyphonic\npolyphony/MS\npolyphosphate/S\npolypropylene/MS\npolystyrene/SM\npolysyllabic\npolysyllable/SM\npolytechnic/MS\npolytheism/SM\npolytheist/SM\npolytheistic\npolythene/M\npolytonal/Y\npolytopes\npolyunsaturated\npolyurethane/SM\npolyvinyl/MS\npomade/MGSD\npomander/MS\npomegranate/SM\npommel/GSMD\npomp/SM\npompadour/MDS\npompano/SM\npompom/SM\npompon's\npomposity/MS\npompous/YP\npompousness/S\nponce/M\nponcho/MS\npond/SMDRGZ\nponder/ZGRD\nponderer/M\nponderous/PY\nponderousness/MS\npone/SM\npongee/MS\nponiard/GSDM\npons/M\npontiff/MS\npontifical/YS\npontificate/XGNDS\npontoon/SMDG\npony/DSMG\nponytail/SM\npooch/GSDM\npoodle/MS\npoof/MS\npooh/DG\npoohs\npool/MDSG\npoolroom/MS\npoolside\npoop/MDSG\npoor/TYRP\npoorboy\npoorhouse/MS\npoorness/MS\npop/SM\npopcorn/MS\npope/SM\npopgun/SM\npopinjay/MS\npoplar/SM\npoplin/MS\npopover/SM\npoppa/MS\npopped\npopper/SM\npoppet/M\npopping\npoppy/SDM\npoppycock/MS\npoppyseed\npopulace/MS\npopular/YS\npopularism\npopularity/UMS\npopularization/SM\npopularize/A\npopularized\npopularizer/MS\npopularizes/U\npopularizing\npopulate/CXNGDS\npopulated/UA\npopulates/A\npopulating/A\npopulation/MC\npopulism/S\npopulist/SM\npopulous/YP\npopulousness/MS\nporcelain/SM\nporch/SM\nporcine\nporcupine/MS\npore/ZGDRS\nporgy/SM\nporing/Y\npork/ZRMS\nporker/M\nporky/TSR\nporn/S\nporno/S\npornographer/SM\npornographic\npornographically\npornography/SM\nporosity/SM\nporous/PY\nporousness/MS\nporphyritic\nporphyry/MS\nporpoise/DSGM\nporridge/MS\nporringer/MS\nport/ABSGZMRD\nportability/S\nportable/U\nportables\nportably\nportage/ASM\nportaged\nportaging\nportal/SM\nportamento/M\nportcullis/MS\nported/CE\nportend/SDG\nportent/SM\nportentous/PY\nportentousness/M\nporter's/A\nporter/DMG\nporterage/M\nporterhouse/SM\nportfolio/MS\nporthole/SM\nportico/M\nporticoes\nporting/E\nportion/KGSMD\nportire/SM\nportliness/SM\nportly/PTR\nportmanteau/SM\nportrait/MS\nportraitist/SM\nportraiture/MS\nportray/GDRS\nportrayal/SM\nportrayer/M\nports/CE\nportulaca/MS\npose/ZGKDRSE\nposed/CA\nposer/KME\nposes/CA\nposeur/MS\nposh/DSRGT\nposing/CA\nposit/SCGD\npositifs\nposition's/EC\nposition/KGASMD\npositionable\npositional/KY\npositions/EC\npositive/RSPYT\npositiveness/S\npositivism/M\npositivist/S\npositivity\npositron/SM\nposs/S\nposse/M\npossess/AGEDS\npossessed/PY\npossession/AEMS\npossessional\npossessive/PSMY\npossessiveness/MS\npossessor/MS\npossibility/SM\npossible/TRS\npossibly\npossum/MS\npost's\npost/ASDRJG\npostage/MS\npostal/S\npostbag/M\npostbox/SM\npostcard/SM\npostcode/SM\npostcondition/S\npostconsonantal\npostdate/DSG\npostdoctoral\nposter/MS\nposterior/SY\nposteriori\nposterity/SM\npostfix/GDS\npostgraduate/SM\nposthaste/S\nposthumous/YP\nposthumousness/M\nposthypnotic\npostilion/MS\npostindustrial\nposting/M\npostlude/MS\npostman/M\npostmarital\npostmark/GSMD\npostmaster/SM\npostmen\npostmeridian\npostmistress/MS\npostmodern\npostmodernist\npostmortem/S\npostnasal\npostnatal\npostoperative/Y\npostorder\npostpaid\npostpartum\npostpone/GLDRS\npostponement/S\npostpositions\npostprandial\npostscript/SM\npostsecondary\npostulate/XGNSD\npostulation/M\npostural\nposture/MGSRD\nposturer/M\npostvocalic\npostwar\nposy/SM\npot/CMS\npotability/SM\npotable/SP\npotableness/M\npotage/M\npotash/MS\npotassium/MS\npotato/M\npotatoes\npotbelly/MSD\npotboil/ZR\npotboiler/M\npotency/MS\npotent/YS\npotentate/SM\npotential/SY\npotentiality/MS\npotentiating\npotentiometer/SM\npotful/SM\npothead/MS\npother/GDMS\npotherb/MS\npotholder/MS\npothole/SDMG\npotholing/M\npothook/SM\npotion/SM\npotlatch/SM\npotluck/MS\npotpie/SM\npotpourri/SM\npotsherd/MS\npotshot/S\npottage/SM\npotted\npotter/RDMSG\npottery/MS\npotting\npotty/SRT\npouch/SDMG\npoulterer/MS\npoultice/DSMG\npoultry/MS\npounce/SDG\npound/KRDGS\npoundage/MS\npounder/MS\npour/DSG\npourer's\npout/GZDRS\npouter/M\npoverty/MS\npow/RZ\npowder/RDGMS\npowderpuff\npowdery\npower/GMD\npowerboat/MS\npowerful/YP\npowerfulness/M\npowerhouse/MS\npowerless/YP\npowerlessness/SM\npowwow/GDMS\npox/GMDS\npp\nppm\nppr\npr\npracticability/S\npracticable/P\npracticably\npractical/YPS\npracticality/SM\npracticalness/M\npractice/BDRSMG\npracticed/U\npracticer/M\npracticum/SM\npractitioner/SM\npraetor/MS\npraetorian/S\npragmatic/S\npragmatical/Y\npragmatics/M\npragmatism/MS\npragmatist/MS\nprairie/MS\npraise's\npraise/ESDG\npraiser/S\npraiseworthiness/MS\npraiseworthy/P\npraising/Y\npraline/MS\npram/MS\nprance/ZGSRD\nprancer/M\nprancing/Y\nprank/SMDG\nprankster/SM\npraseodymium/SM\nprate/DSRGZ\nprater/M\npratfall/MS\nprating/Y\nprattle/DRSGZ\nprattler/M\nprattling/Y\nprawn/MDSG\npraxes\npraxis/M\npray/DRGZS\nprayer/M\nprayerbook\nprayerful/YP\nprayerfulness/M\npreach/DRSGLZJ\npreacher/M\npreaching/Y\npreachment/MS\npreachy/RT\npreadolescence/S\npreallocate/XGNDS\npreallocation/M\npreallocator/S\npreamble/MGDS\npreamp\npreamplifier/M\nprearrange/LSDG\nprearrangement/SM\npreassign/SDG\npreauthorize\nprebendary/M\nprecancel/DGS\nprecancerous\nprecarious/PY\nprecariousness/MS\nprecaution/SGDM\nprecautionary\nprecede/DSG\nprecedence/SM\nprecedent/SDM\nprecedented/U\nprecept/SMV\npreceptive/Y\npreceptor/MS\nprecess/DSG\nprecession/M\nprecinct/MS\npreciosity/MS\nprecious/PYS\npreciousness/S\nprecipice/MS\nprecipitable\nprecipitant/S\nprecipitate/YNGVPDSX\nprecipitateness/M\nprecipitation/M\nprecipitous/YP\nprecipitousness/M\nprecise/XYTRSPN\npreciseness/SM\nprecision/M\npreclude/GDS\npreclusion/S\nprecocious/YP\nprecociousness/MS\nprecocity/SM\nprecode/D\nprecognition/SM\nprecognitive\nprecollege/M\nprecolonial\nprecomputed\npreconceive/GSD\npreconception/SM\nprecondition/GMDS\npreconscious\nprecook/GDS\nprecursor/SM\nprecursory\nprecut\npredate/NGDSX\npredation/CMS\npredator/SM\npredatory\npredecease/SDG\npredecessor/MS\npredeclared\npredecline\npredefine/GSD\npredefinition/SM\npredesignate/GDS\npredestination/SM\npredestine/SDG\npredetermination/MS\npredetermine/ZGSRD\npredeterminer/M\npredicable/S\npredicament/SM\npredicate/VGNXSD\npredication/M\npredicator\npredict/BSDGV\npredictability/UMS\npredictable/U\npredictably/U\npredicted/U\nprediction/MS\npredictive/Y\npredictor/MS\npredigest/GDS\npredilect\npredilection/SM\npredispose/SDG\npredisposition/MS\npredoctoral\npredominance/SM\npredominant/Y\npredominate/YSDGN\npredomination/M\npreemie/MS\npreeminence/SM\npreeminent/Y\npreemployment/M\npreempt/GVSD\npreemption/SM\npreemptive/Y\npreemptor/M\npreen/SRDG\npreener/M\npreexist/DSG\npreexistence/SM\npreexistent\npref/RZ\nprefab/MS\nprefabbed\nprefabbing\nprefabricate/XNGDS\nprefabrication/M\npreface/DRSGM\nprefacer/M\nprefatory\nprefect/MS\nprefecture/MS\nprefer/BL\npreferable/P\npreferableness/M\npreferably\npreference/MS\npreferential/Y\npreferment/SM\npreferred\npreferring\nprefiguration/M\nprefigure/SDG\nprefix/MDSG\npreflight/SGDM\npreform/DSG\npregnancy/SM\npregnant/Y\npreheat/GDS\nprehensile\nprehistoric\nprehistorical/Y\nprehistory/SM\npreindustrial\npreinitialize/SDG\npreinterview/M\npreisolated\nprejudge/DRSG\nprejudger/M\nprejudgment/SM\nprejudice/MSDG\nprejudiced/U\nprejudicial/PY\nprekindergarten/MS\nprelacy/MS\nprelate/SM\npreliminarily\npreliminary/S\npreliterate/S\npreloaded\nprelude/GMDRS\npreluder/M\npremarital/Y\npremarket\npremature/SPY\nprematureness/M\nprematurity/M\npremed/S\npremedical\npremeditate/XDSGNV\npremeditated/Y\npremeditation/M\npremenstrual\npremier/GSDM\npremiere/MS\npremiership/SM\npremise/GMDS\npremiss's\npremium/MS\npremix/GDS\npremolar/S\npremonition/SM\npremonitory\nprenatal/Y\nprenuptial\npreoccupation/MS\npreoccupy/DSG\npreoperative\npreordain/DSLG\nprep/SM\nprepackage/GSD\nprepaid\npreparation/SM\npreparative/SYM\npreparatory\nprepare/ZDRSG\nprepared/UP\npreparedly\npreparedness/USM\nprepay/GLS\nprepayment/SM\nprepender/S\nprepends\npreplanned\npreponderance/SM\npreponderant/Y\npreponderate/DSYGN\npreposition/SDMG\nprepositional/Y\nprepossess/GSD\nprepossessing/U\nprepossession/MS\npreposterous/PY\npreposterousness/M\nprepped\nprepping\npreppy/RST\npreprepared\npreprint/SGDM\npreprocessed\npreprocessing\npreprocessor/S\npreproduction\npreprogrammed\nprepubescence/S\nprepubescent/S\nprepublication/M\nprepuce/SM\nprequel/S\npreradiation\nprerecord/DGS\npreregister/DSG\npreregistration/MS\nprerequisite/SM\nprerogative/SDM\npres/S\npresage/GMDRS\npresager/M\npresbyopia/MS\npresbyter/MS\npresbyterian\npresbytery/MS\npreschool/RSZ\nprescience/SM\nprescient/Y\nprescribe/RSDG\nprescribed/U\nprescriber/M\nprescript/SVM\nprescription/SM\nprescriptive/Y\npreselect/SGD\npresence/SM\npresent/SLBDRYZGP\npresentable/P\npresentableness/M\npresentably/A\npresentation/AMS\npresentational/A\npresented/A\npresenter/A\npresentiment/MS\npresentment/SM\npresents/A\npreservation/SM\npreservationist/S\npreservative/SM\npreserve/DRSBZG\npreserved/U\npreserver/M\npreset/S\npresetting\npreshrank\npreshrink/SG\npreshrunk\npreside/DRSG\npresidency/MS\npresident/SM\npresidential/Y\npresider/M\npresidia\npresidium/M\npresoaks\npresort/GDS\npress/ACDSG\npressed/U\npresser/MS\npressing/YS\npressingly/C\npressman/M\npressmen\npressure/DSMG\npressurization/MS\npressurize/DSRGZ\npressurized/U\nprestidigitate/NX\nprestidigitation/M\nprestidigitator/M\nprestidigitatorial\nprestige/MS\nprestigious/PY\npresto/S\npresumably\npresume/BGDRS\npresumer/M\npresuming/Y\npresumption/MS\npresumptive/Y\npresumptuous/YP\npresumptuousness/SM\npresuppose/GDS\npresupposition/S\npretax\npreteen/S\npretend/SDRZG\npretended/Y\npretender/M\npretending/U\npretense/MNVSX\npretension/GDM\npretentious/UYP\npretentiousness/S\npreterit/SM\npreterite's\npreternatural/Y\npretest/SDG\npretext/SMDG\npretreated\npretreatment/S\npretrial\nprettify/SDG\nprettily\nprettiness/SM\npretty/TGPDRS\npretzel/SM\nprevail/SGD\nprevailing/Y\nprevalence/MS\nprevalent/SY\nprevaricate/DSXNG\nprevaricator/MS\nprevent/BSDRGV\npreventable/U\npreventably\npreventative/S\npreventer/M\nprevention/MS\npreventive/SPY\npreventiveness/M\npreview/ZGSDRM\nprevious/Y\nprevision/SGMD\nprewar\nprexes\nprey/SMDG\npreyer's\npriapic\nprice's\nprice/AGSD\npriced/U\npriceless\npricer/MS\npricey\npricier\npriciest\nprick/RDSYZG\npricker/M\npricking/M\nprickle/GMDS\nprickliness/S\nprickly/RTP\npride/GMDS\nprideful/Y\nprier/M\npriest/SMYDG\npriestess/MS\npriesthood/SM\npriestliness/SM\npriestly/PTR\nprig/SM\nprigged\nprigging\npriggish/PYM\npriggishness/S\nprim/SPJGZYDR\nprimacy/MS\nprimal\nprimarily\nprimary/MS\nprimate/MS\nprime/PYS\nprimed/U\nprimely/M\nprimeness/M\nprimer/M\nprimeval/Y\npriming/M\nprimitive/YPS\nprimitiveness/SM\nprimitivism/M\nprimmed\nprimmer\nprimmest\nprimming\nprimness/MS\nprimogenitor/MS\nprimogeniture/MS\nprimordial/YS\nprimp/DGS\nprimrose/MGSD\nprince/SMY\nprincedom/MS\nprinceliness/SM\nprincely/PRT\nprincess/MS\nprincipal/SY\nprincipality/MS\nprinciple/SDMG\nprincipled/U\nprint/AGDRS\nprintable/U\nprintably\nprinted/U\nprinter/AM\nprinters\nprinting/SM\nprintmake/ZGR\nprintmaker/M\nprintmaking/M\nprintout/S\nprior/YS\nprioress/MS\npriori\nprioritize/DSRGZJ\npriority/MS\npriory/SM\nprise/GMAS\nprised\nprism/MS\nprismatic\nprison/DRMSGZ\nprisoner/M\nprissily\nprissiness/SM\nprissy/RSPT\npristine/Y\nprithee/S\nprivacy/MS\nprivate/NVYTRSXP\nprivateer/SMDG\nprivateness/M\nprivation/MCS\nprivative/Y\nprivatization/S\nprivatize/GSD\nprivet/SM\nprivilege/SDMG\nprivileged/U\nprivily\nprivy/SRMT\nprize/DSRGZM\nprized/A\nprizefight/SRMGJZ\nprizefighter/M\nprizefighting/M\nprizewinner/S\nprizewinning\npro/MS\nproactive\nprob/RBJ\nprobabilist\nprobabilistic\nprobabilistically\nprobability/SM\nprobable/S\nprobably\nprobate/NVMX\nprobated/A\nprobates/A\nprobating/A\nprobation's/A\nprobation/MRZ\nprobational\nprobationary/S\nprobationer/M\nprobative/A\nprober/M\nprobity/SM\nproblem/SM\nproblematic/S\nproblematical/UY\nproboscis/MS\nprocaine/MS\nprocedural/SY\nprocedure/MS\nproceed/JRDSG\nproceeder/M\nproceeding/M\nprocess/BSDMG\nprocessed/UA\nprocesses/A\nprocession/GD\nprocessional/YS\nprocessor/MS\nproclamation/MS\nproclivity/MS\nproconsular\nprocrastinate/XNGDS\nprocrastination/M\nprocrastinator/MS\nprocreational\nprocreatory\nprocrustean\nproctor/GSDM\nproctorial\nprocurable/U\nprocure/L\nprocurement/MS\nprod/S\nprodded\nprodding\nprodigal/SY\nprodigality/S\nprodigious/PY\nprodigiousness/M\nprodigy/MS\nproduce/AZGDRS\nproducer/AM\nproducible/A\nproduct/V\nproduction/ASM\nproductive/PY\nproductively/UA\nproductiveness/MS\nproductivities\nproductivity's\nproductivity/A\nproductize/GZRSD\nprof/S\nprofanation/S\nprofane/YPDRSG\nprofaneness/MS\nprofanity/MS\nprofessed/Y\nprofession/SM\nprofessional/USY\nprofessionalism/SM\nprofessionalize/GSD\nprofessor/SM\nprofessorial/Y\nprofessorship/SM\nproffer/GSD\nproficiency/SM\nproficient/YS\nprofit/GZDRB\nprofitability/MS\nprofitable/UP\nprofitableness/MU\nprofitably/U\nprofiteer/GSMD\nprofiterole/MS\nprofitless\nprofligacy/S\nprofligate/YS\nproforma/S\nprofound/PTYR\nprofoundity\nprofoundness/SM\nprofundity/MS\nprofuse/YP\nprofuseness/MS\nprogenitor/SM\nprogeny/M\nprogesterone/SM\nprognathous\nprognoses\nprognosis/M\nprognostic/S\nprognosticate/NGVXDS\nprognostication/M\nprognosticator/S\nprogram/CSA\nprogramed\nprograming\nprogrammability\nprogrammable/S\nprogrammed/CA\nprogrammer/ASM\nprogramming/CA\nprogrammings\nprogress/MSDVG\nprogression/SM\nprogressive/SPY\nprogressiveness/SM\nprogressivism\nprohibit/VGSRD\nprohibiter/M\nprohibition/MS\nprohibitionist/MS\nprohibitive/PY\nprohibitiveness/M\nprohibitory\nproject/MDVGS\nprojected/AU\nprojectile/MS\nprojection/MS\nprojectionist/MS\nprojective/Y\nprojector/SM\nprolegomena\nproletarian/S\nproletarianization/M\nproletarianized\nproletariat/SM\nproliferate/GNVDSX\nproliferation/M\nprolific/P\nprolifically\nprolix/Y\nprolixity/MS\nprologize\nprologue/MGSD\nprologuize\nprolong/G\nprolongate/NGSDX\nprolongation/M\nprolonger/M\npromenade/GZMSRD\npromenader/M\npromethium/SM\nprominence/MS\nprominent/Y\npromiscuity/MS\npromiscuous/PY\npromiscuousness/M\npromise/GD\npromising/UY\npromissory\npromontory/MS\npromote/GVZBDR\npromoter/M\npromotive/P\npromotiveness/M\nprompt/SGJTZPYDR\nprompted/U\nprompter/M\npromptitude/SM\npromptness/MS\npromulgate/NGSDX\npromulgation/M\npromulgator/MS\npron\nprone/PY\nproneness/MS\nprong/SGMD\npronghorn/SM\npronominalization\npronominalize\npronounce/GLSRD\npronounceable/U\npronounced/U\npronouncedly\npronouncement/SM\npronouncer/M\npronto\npronunciation/SM\nproof/SEAM\nproofed/A\nproofer\nproofing/M\nproofread/GZSR\nproofreader/M\nprop/SZ\npropaganda/SM\npropagandist/SM\npropagandistic\npropagandize/DSG\npropagate/SDVNGX\npropagated/U\npropagation/M\npropagator/MS\npropel/S\npropellant/MS\npropelled\npropeller/MS\npropelling\npropensity/MS\nproper/PYRT\nproperness/M\npropertied/U\nproperty/SDM\nprophecy/SM\nprophesier/M\nprophesy/GRSDZ\nprophet/SM\nprophetess/S\nprophetic\nprophetical/Y\nprophylactic/S\nprophylaxes\nprophylaxis/M\npropinquity/MS\npropionate/M\npropitiate/GNXSD\npropitiatory\npropitious/YP\npropitiousness/M\nproponent/MS\nproportion/ESGDM\nproportional/SY\nproportionality/M\nproportionate/YGESD\nproportioner/M\nproportionment/M\nproposal/SM\npropped\npropping\nproprietary/S\nproprietor/SM\nproprietorial\nproprietorship/SM\nproprietress/MS\npropriety/MS\nproprioception\nproprioceptive\npropulsion/MS\npropulsive\npropylene/M\nprorogation/SM\nprorogue\npros/DSRG\nprosaic\nprosaically\nproscenium/MS\nprosciutti\nprosciutto/SM\nproscription/SM\nproscriptive\nprose/M\nprosecute/SDBXNG\nprosecution/M\nprosecutor/MS\nproselyte/SDGM\nproselytism/MS\nproselytize/ZGDSR\nproser/M\nprosodic/S\nprosody/MS\nprospect/DMSVG\nprospection/SM\nprospective/SYP\nprospectiveness/M\nprospector/MS\nprospectus/SM\nprosper/GSD\nprosperity/MS\nprosperous/PY\nprosperousness/M\nprostate\nprostheses\nprosthesis/M\nprosthetic/S\nprosthetics/M\nprostitute/DSXNGM\nprostitution/M\nprostrate/SDXNG\nprostration/M\nprosy/RT\nprotactinium/MS\nprotagonist/SM\nprotean/S\nprotease/M\nprotect/DVGS\nprotected/UY\nprotection/MS\nprotectionism/MS\nprotectionist/MS\nprotective/YPS\nprotectiveness/S\nprotector/MS\nprotectorate/SM\nprotein/MS\nproteolysis/M\nproteolytic\nprotest/G\nprotestant/S\nprotestantism\nprotestation/MS\nprotesting/Y\nprotocol/DMGS\nprotoplasm/MS\nprotoplasmic\nprototype/SDGM\nprototypic\nprototypical/Y\nprotozoa\nprotozoan/MS\nprotozoic\nprotozoon's\nprotract/DG\nprotrude/SDG\nprotrusile\nprotrusion/MS\nprotrusive/PY\nprotuberance/S\nprotuberant\nprotg/SM\nprotges\nproud/TRY\nprov/DRGZB\nprovabilities\nprovability's\nprovability/U\nprovable/P\nprovableness/M\nprovably\nprove/ESDAG\nproved/U\nproven/U\nprovenance/SM\nprovender/SDG\nprovenience/SM\nprovenly\nprover/M\nproverb/DG\nproverbial/Y\nprovide/DRSBGZ\nprovided/U\nprovidence/SM\nprovident/Y\nprovidential/Y\nprovider/M\nprovince/SM\nprovincial/SY\nprovincialism/SM\nprovision/R\nprovisional/YS\nprovisioner/M\nproviso/MS\nprovocateur/S\nprovocative/P\nprovocativeness/SM\nprovoke/GZDRS\nprovoked/U\nprovoking/Y\nprovolone/SM\nprovost/MS\nprow/TRMS\nprowess/SM\nprowl/RDSZG\nprowler/M\nproximal/Y\nproximate/PY\nproximateness/M\nproximity/MS\nproxy/SM\nprude/MS\nprudence/SM\nprudent/Y\nprudential/SY\nprudery/MS\nprudish/YP\nprudishness/SM\nprune/DSRGZM\npruner/M\nprurience/MS\nprurient/Y\nprussic\npry/DRSGTZ\npryer's\nprying/Y\nprcis/MDG\npsalm/SGDM\npsalmist/SM\npsalter\npsaltery/MS\npsephologist/M\npseudo/S\npseudonym/SM\npseudonymous\npseudopod\npseudoscience/S\npshaw/SDG\npsi/S\npsittacoses\npsittacosis/M\npsoriases\npsoriasis/M\npsst/S\npsych/SDG\npsyche/M\npsychedelic/S\npsychedelically\npsychiatric\npsychiatrist/SM\npsychiatry/MS\npsychic/MS\npsychical/Y\npsycho/SM\npsychoacoustic/S\npsychoacoustics/M\npsychoactive\npsychoanalysis/M\npsychoanalyst/S\npsychoanalytic\npsychoanalytical\npsychoanalyze/SDG\npsychobabble/S\npsychobiology/M\npsychocultural\npsychodrama/MS\npsychogenic\npsychokinesis/M\npsycholinguistic/S\npsycholinguistics/M\npsycholinguists\npsychological/Y\npsychologist/MS\npsychology/MS\npsychometric/S\npsychometrics/M\npsychometry/M\npsychoneuroses\npsychoneurosis/M\npsychopath/M\npsychopathic/S\npsychopathology/M\npsychopaths\npsychopathy/SM\npsychophysic/S\npsychophysical/Y\npsychophysics/M\npsychophysiology/M\npsychos/S\npsychosis/M\npsychosocial/Y\npsychosomatic/S\npsychosomatics/M\npsychotherapeutic/S\npsychotherapist/MS\npsychotherapy/SM\npsychotic/S\npsychotically\npsychotropic/S\npsychs\npt/C\nptarmigan/MS\npterodactyl/SM\nptomaine/MS\npub/MS\npubbed\npubbing\npubertal\npuberty/MS\npubes\npubescence/S\npubescent\npubic\npubis/M\npublic/YSP\npublican/AMS\npublication/AMS\npublicist/SM\npublicity/SM\npublicize/SDG\npublicized/U\npublicness/M\npublics/A\npublish/JDRSBZG\npublishable/U\npublished/UA\npublisher/ASM\npublishes/A\npublishing/M\npuce/SM\npuck/GZSDRM\npucker/DG\npuckish/YP\npuckishness/S\npudding/MS\npuddle/JMGRSD\npuddler/M\npuddling/M\npuddly\npudenda\npudendum/M\npudginess/SM\npudgy/PRT\npueblo/SM\npuerile/Y\npuerility/SM\npuerperal\npuers\npuff/SGZDRM\npuffball/SM\npuffer/M\npuffery/M\npuffin/SM\npuffiness/S\npuffy/PRT\npug/MS\npugged\npugging\npugilism/SM\npugilist/S\npugilistic\npugnacious/YP\npugnaciousness/MS\npugnacity/SM\npuissant/Y\npuke/GDS\npukka\npulchritude/SM\npulchritudinous/M\npule/GDS\npull/DRGZSJ\npullback/S\npullet/SM\npulley/SM\npullout/S\npullover/SM\npulmonary\npulp/MDRGS\npulpiness/S\npulpit/MS\npulpwood/MS\npulpy/PTR\npulsar/MS\npulsate/NGSDX\npulsation/M\npulse's\npulse/ADSG\npulser\npulverable\npulverization/MS\npulverize/GZSRD\npulverized/U\npulverizer/M\npulverizes/UA\npuma/SM\npumice/SDMG\npummel/SDG\npump/GZSMDR\npumpernickel/SM\npumping/M\npumpkin/MS\npun/MS\npunch/GRSDJBZ\npunchbowl/M\npunched/U\npuncheon/MS\npuncher/M\npunchline/S\npunchy/RT\npunctilio/SM\npunctilious/PY\npunctiliousness/SM\npunctual/PY\npunctualities\npunctuality/UM\npunctualness/M\npunctuate/SDXNG\npunctuation/M\npunctuational\npuncture/SDMG\npundit/SM\npunditry/S\npungency/MS\npungent/Y\npuniness/MS\npunish/RSDGBL\npunished/U\npunisher/M\npunishment/MS\npunitive/YP\npunitiveness/M\npunk/TRMS\npunky/PRS\npunned\npunning\npunster/SM\npunt/GZMDRS\npunter/M\npuny/PTR\npup/MS\npupa/M\npupae\npupal\npupate/NGSD\npupil/SM\npupillage/M\npupped\npuppet/SM\npuppeteer/SM\npuppetry/MS\npupping\npuppy/GSDM\npuppyish\npurblind\npurchasable\npurchase/GASD\npurchaser/MS\npurdah/M\npurdahs\npure/PYTGDR\npurebred/S\npuree/DSM\npureeing\npureness/MS\npurgation/M\npurgative/MS\npurgatorial\npurgatory/SM\npurge/GZDSR\npurger/M\npurify/GSRDNXZ\npurine/SM\npurism/MS\npurist/MS\npuristic\npuritan/SM\npuritanic\npuritanical/Y\npuritanism/S\npurity/SM\npurl/MDGS\npurlieu/SM\npurloin/DRGS\npurloiner/M\npurple/MTGRSD\npurplish\npurport/DRSZG\npurported/Y\npurpose/SDVGYM\npurposeful/YP\npurposefulness/S\npurposeless/PY\npurposelessness/M\npurposive/YP\npurposiveness/M\npurr/DSG\npurring/Y\npurse/DSRGZM\npurser/M\npursuance/MS\npursuant\npursue/ZGRSD\npursuer/M\npursuit/MS\npurulence/MS\npurulent\npurvey/DGS\npurveyance/MS\npurveyor/MS\npurview/SM\npus/SM\npush/DSRBGZ\npushbutton/S\npushcart/SM\npushchair/SM\npushdown\npusher/M\npushily\npushiness/MS\npushover/SM\npushy/PRT\npusillanimity/MS\npusillanimous/Y\npuss/S\npussy/TRSM\npussycat/S\npussyfoot/DSG\npustular\npustule/MS\nput/IS\nputative/Y\nputout/S\nputrefaction/SM\nputrefactive\nputrefy/DSG\nputrescence/MS\nputrescent\nputrid/YP\nputridity/M\nputridness/M\nputsch/S\nputt/SGZMDR\nputted/I\nputtee/MS\nputter/RDMGZ\nputting/I\nputty/SDMG\nputtying/M\npuzzle/JRSDZLG\npuzzlement/MS\npuzzler/M\npvt\npygmy/SM\npyknotic\npylon/SM\npylori\npyloric\npylorus/M\npyorrhea/SM\npyramid/GMDS\npyramidal/Y\npyre/MS\npyridine/M\npyrimidine/SM\npyrite/MS\npyroelectric\npyroelectricity/SM\npyrolysis/M\npyrolyze/RSM\npyromania/MS\npyromaniac/SM\npyrometer/MS\npyrometry/M\npyrophosphate/M\npyrotechnic/S\npyrotechnical\npyrotechnics/M\npyroxene/M\npyroxenite/M\npython/MS\npyx/MDSG\npres\nq\nq's\nqr\nqt\nqty\nqua\nquack/SDG\nquackery/MS\nquackish\nquad/SM\nquadded\nquadding\nquadrangle/MS\nquadrangular/M\nquadrant/MS\nquadraphonic/S\nquadrapole\nquadratic/SM\nquadratical/Y\nquadrature/MS\nquadrennial/SY\nquadrennium/MS\nquadric\nquadriceps/SM\nquadrilateral/S\nquadrille/XMGNSD\nquadrillion/MH\nquadripartite/NY\nquadriplegia/SM\nquadriplegic/SM\nquadrivia\nquadrivium/M\nquadruped/MS\nquadrupedal\nquadruple/GSD\nquadruplet/SM\nquadruplicate/GDS\nquadruply/NX\nquadrupole\nquadword/MS\nquaff/SRDG\nquaffer/M\nquagmire/DSMG\nquahog/MS\nquail/GSDM\nquaint/PTYR\nquaintness/MS\nquake/GZDSR\nquaky/RT\nqualification/ME\nqualified/UY\nqualifier/SM\nqualify/EGXSDN\nqualitative/Y\nquality/MS\nqualm/SM\nqualmish\nquandary/MS\nquangos\nquanta/M\nquantifiable/U\nquantified/U\nquantifier/M\nquantify/GNSRDZX\nquantile/S\nquantitative/PY\nquantitativeness/M\nquantity/MS\nquantization/MS\nquantize/ZGDRS\nquantizer/M\nquantum/M\nquarantine/DSGM\nquark/SM\nquarrel/SZDRMG\nquarreler/M\nquarrellings\nquarrelsome/PY\nquarrelsomeness/MS\nquarrier/M\nquarry/RSDGM\nquarryman/M\nquarrymen\nquart/RMSZ\nquarter/MDRYG\nquarterback/SGMD\nquarterdeck/MS\nquarterer/M\nquarterfinal/MS\nquartering/M\nquarterly/S\nquartermaster/MS\nquarterstaff/M\nquarterstaves\nquartet/SM\nquartic/S\nquartile/SM\nquarto/SM\nquartz/SM\nquartzite/M\nquasar/SM\nquash/GSD\nquasi\nquasilinear\nquaternary/S\nquaternion/SM\nquatrain/SM\nquaver/GDS\nquavering/Y\nquavery\nquay/SM\nquayside/M\nqueasily\nqueasiness/SM\nqueasy/TRP\nqueen/SGMDY\nqueenly/RT\nqueer/STGRDYP\nqueerness/S\nquell/SRDG\nqueller/M\nquench/GZRSDB\nquenchable/U\nquenched/U\nquencher/M\nquenchless\nquern/M\nquerulous/YP\nquerulousness/S\nquery/MGRSD\nquest/FSIM\nquested/A\nquester's\nquester/AS\nquesting\nquestion/SMRDGBZJ\nquestionable/P\nquestionableness/M\nquestionably/U\nquestioned/UA\nquestioner/M\nquestioning/UY\nquestionnaire/MS\nquests/A\nqueue/GZMDSR\nqueued/C\nqueuer/M\nqueues/C\nqueuing/C\nquibble/GZRSD\nquibbler/M\nquiche/SM\nquick/RNYTXPS\nquicken/RDG\nquickie/MS\nquicklime/SM\nquickness/MS\nquicksand/MS\nquicksilver/GDMS\nquickstep/SM\nquid/SM\nquiesce/D\nquiescence/MS\nquiescent/YP\nquiet/UTGPSDRY\nquieted/E\nquieten/SGD\nquieter's\nquieter/E\nquieting/E\nquietly/E\nquietness/MS\nquiets/E\nquietude/IEMS\nquietus/MS\nquill/GSDM\nquilt/SZJGRDM\nquilter/M\nquilting/M\nquince/SM\nquincentenary/M\nquincy/M\nquinine/MS\nquinquennial/Y\nquinsy/SM\nquint/MS\nquintessence/SM\nquintessential/Y\nquintet/SM\nquintic\nquintile/SM\nquintillion/MH\nquintillionth/M\nquintuple/SDG\nquintuplet/MS\nquip/MS\nquipped\nquipper\nquipping\nquipster/SM\nquire/MDSG\nquired/AI\nquires/AI\nquiring/IA\nquirk/SGMD\nquirkiness/SM\nquirky/PTR\nquirt/SDMG\nquisling/SM\nquit/DGS\nquitclaim/GDMS\nquite/SADG\nquittance/SM\nquitter/SM\nquitting\nquiver/GDS\nquivering/Y\nquivery\nquixotic\nquixotically\nquiz/M\nquizzed\nquizzer/SM\nquizzes\nquizzical/Y\nquizzing\nquo/H\nquoin/SGMD\nquoit/GSDM\nquondam\nquonset\nquorate/I\nquorum/MS\nquot/GDRB\nquota/MS\nquotability/S\nquotation/SM\nquote/UGSD\nquoter/M\nquotidian/S\nquotient/SM\nqwerty\nqwertys\nr's\nr/TGVJ\nrabbet/GSMD\nrabbi/MS\nrabbinate/MS\nrabbinic\nrabbinical/Y\nrabbit/MRDSG\nrabbiter/M\nrabble/GMRSD\nrabbler/M\nrabid/YP\nrabidness/SM\nrabies\nrabis\nraccoon/SM\nrace/MZGDRSJ\nracecourse/MS\nracegoers\nracehorse/SM\nraceme/MS\nracer/M\nracetrack/SMR\nraceway/SM\nracial/Y\nracialism/MS\nracialist/MS\nracily\nraciness/MS\nracism/S\nracist/MS\nrack/GDRMS\nracket/SMDG\nracketeer/MDSJG\nrackety\nraconteur/SM\nracoon's\nracquet's\nracquetball/S\nracy/RTP\nrad/S\nradar/SM\nradarscope/MS\nradded\nradder\nraddest\nradding\nradial/SY\nradian/SM\nradiance/SM\nradiant/YS\nradiate/XSDYVNG\nradiation/M\nradiative/Y\nradiator/MS\nradical/SPY\nradicalism/MS\nradicalization/S\nradicalize/GSD\nradicalness/M\nradices's\nradii/M\nradio/SMDG\nradioactive/Y\nradioactivity/MS\nradioastronomical\nradioastronomy\nradiocarbon/MS\nradiochemical/Y\nradiochemistry/M\nradiogalaxy/S\nradiogram/SM\nradiographer/MS\nradiographic\nradiography/MS\nradioisotope/SM\nradiologic\nradiological/Y\nradiologist/MS\nradiology/MS\nradioman/M\nradiomen\nradiometer/SM\nradiometric\nradiometry/MS\nradionics\nradionuclide/M\nradiopasteurization\nradiophone/MS\nradiophysics\nradioscopy/SM\nradiosonde/SM\nradiosterilization\nradiosterilized\nradiotelegraph\nradiotelegraphs\nradiotelegraphy/MS\nradiotelephone/SM\nradiotherapist/SM\nradiotherapy/SM\nradish/MS\nradium/MS\nradius/M\nradix/SM\nradon/SM\nraffia/SM\nraffish/PY\nraffishness/SM\nraffle/MSDG\nraft/GZSMDR\nrafter/DM\nrag/GSMD\nraga/MS\nragamuffin/MS\nragbag/SM\nrage/MS\nragged/PRYT\nraggedness/SM\nraggedy/TR\nragging\nraging/Y\nraglan/MS\nragout/SMDG\nragtag/MS\nragtime/MS\nragweed/MS\nragwort/M\nrah/DG\nrahs\nraid/MDRSGZ\nraider/M\nrail's\nrail/CDGS\nrailbird/S\nrailer/SM\nrailhead/SM\nrailing/MS\nraillery/MS\nrailroad/SZRDMGJ\nrailroader/M\nrailroading/M\nrailway/MS\nrailwaymen\nraiment/SM\nrain/GSDM\nrainbow/MS\nraincloud/S\nraincoat/SM\nraindrop/SM\nrainfall/SM\nrainforest's\nrainless\nrainmaker/SM\nrainmaking/MS\nrainproof/GSD\nrainstorm/SM\nrainwater/MS\nrainy/RT\nraise/DSRGZ\nraiser/M\nraisin/MS\nraising/M\nraj/M\nrajah/M\nrajahs\nrake/MGDRS\nraker/M\nrakish/PY\nrakishness/MS\nrally/GSD\nram/SM\nramble/JRSDGZ\nrambler/M\nrambling/Y\nrambunctious/PY\nrambunctiousness/S\nramekin/SM\nramie/MS\nramification/M\nramify/XNGSD\nramjet/SM\nrammed\nramming\nramp/GMDS\nrampage/SDG\nrampancy/S\nrampant/Y\nrampart/SGMD\nramrod/MS\nramrodded\nramrodding\nrams/S\nramshackle\nran/A\nranch/ZRSDMJG\nrancher/M\nrancho/SM\nrancid/P\nrancidity/MS\nrancidness/SM\nrancor/SM\nrancorous/Y\nrand/MDGS\nrandiness/S\nrandom/PYS\nrandomization/SM\nrandomize/SRDG\nrandomness/SM\nrandy/PRST\nranee/SM\nrang/GZDR\nrange/SM\nranged/C\nrangeland/S\nranger/M\nranges/C\nranginess/S\nranging/C\nrangy/RPT\nrani's\nrank/GZTYDRMPJS\nranked/U\nranker/M\nranking/M\nrankle/SDG\nrankness/MS\nransack/GRDS\nransacker/M\nransom/ZGMRDS\nransomer/M\nrant/GZDRJS\nranter/M\nranting/Y\nrap/MDRSZG\nrapacious/YP\nrapaciousness/MS\nrapacity/MS\nrape/SM\nrapeseed/M\nrapid/YRPST\nrapidity/MS\nrapidness/S\nrapier/SM\nrapine/SM\nrapist/MS\nrapped\nrappel/S\nrappelled\nrappelling\nrapper/SM\nrapping/M\nrapport/SM\nrapporteur/SM\nrapprochement/SM\nrapscallion/MS\nrapt/YP\nraptness/S\nrapture/MGSD\nrapturous/YP\nrapturousness/M\nrare/YTPGDRS\nrarebit/MS\nrarefaction/MS\nrarefy/GSD\nrareness/MS\nrarity/SM\nrascal/SMY\nrash/PZTYSR\nrasher/M\nrashness/S\nrasp/SGJMDR\nraspberry/SM\nrasper/M\nrasping/Y\nraspy/RT\nraster/MS\nrat/MDRSJZGB\nratchet/MDSG\nrate's\nrate/KNGSD\nrateable\nrated/U\nratepayer/SM\nrater/M\nrather\nrathskeller/SM\nratifier/M\nratify/ZSRDGXN\nrating/M\nratio/MS\nratiocinate/VNGSDX\nratiocination/M\nration/DSMG\nrational/YPS\nrationale/SM\nrationalism/SM\nrationalist/S\nrationalistic\nrationality/MS\nrationalization/SM\nrationalize/ZGSRD\nrationalizer/M\nrationalness/M\nratlike\nratline/SM\nrattail\nrattan/MS\nratted\nratter/MS\nratting\nrattle/RSDJGZ\nrattlebrain/DMS\nrattlesnake/MS\nrattletrap/MS\nrattling/Y\nrattly/TR\nrattrap/SM\nratty/RT\nraucous/YP\nraucousness/SM\nraunchily\nraunchiness/S\nraunchy/RTP\nravage/GZRSD\nravager/M\nrave/ZGDRSJ\nravel/UGDS\nraveling/S\nraven/JGMRDS\nravenous/YP\nraver/M\nravine/SDGM\nravioli/SM\nravish/LSRDZG\nravisher/M\nravishing/Y\nravishment/SM\nraw/PSRYT\nrawboned\nrawhide/SDMG\nrawness/SM\nray/GSMD\nrayon/SM\nraze/DRSG\nrazer/M\nrazor/MDGS\nrazorback/SM\nrazorblades\nrazz/GDS\nrazzmatazz/S\nrcpt\nrd\nre/YM\nreabbreviate\nreach/GRB\nreachability\nreachable/U\nreachably\nreached/U\nreacher/M\nreacquisition\nreactant/SM\nreacted/U\nreaction\nreactionary/SM\nreactivity\nread/JGZBR\nreadability/MS\nreadable/P\nreadably\nreaddress/G\nreader/M\nreadership/MS\nreadied\nreadies\nreadily\nreadiness/UM\nreadinesses\nreading/M\nreadopt/G\nreadout/MS\nreads/A\nready/TUPR\nreadying\nreal/RSTP\nrealism's\nrealism/U\nrealisms\nrealist/SM\nrealistic/U\nrealistically/U\nreality/USM\nrealizability/MS\nrealizable/SMP\nrealizableness/M\nrealizably/S\nrealization/MS\nrealize/JRSDBZG\nrealized/U\nrealizer/M\nrealizes/U\nrealizing/MY\nrealm/M\nrealness/S\nrealpolitik/SM\nrealtor's\nrealty/SM\nream/MDRGZ\nreamer/M\nreanimate\nreap/SGZ\nreaper/M\nreappraise/G\nrear/DRMSG\nrearguard/MS\nrearmost\nrearrange/L\nrearward/S\nreason/UBDMG\nreasonable/UP\nreasonableness/SMU\nreasonably/U\nreasoner/SM\nreasoning/MS\nreasonless\nreasons\nreassess/GL\nreassuringly/U\nreattach/GSL\nreawakening/M\nrebate/M\nrebel/MS\nrebeller\nrebellion/SM\nrebellious/YP\nrebelliousness/MS\nrebid\nrebidding\nrebind/G\nrebirth\nreboil/G\nrebook\nreboot/ZR\nrebound/G\nrebroadcast/MG\nrebuke/RSDG\nrebuking/Y\nrebus\nrebuttal/SM\nrebutting\nrec\nrec'd\nrecalcitrance/SM\nrecalcitrant/S\nrecalibrate/N\nrecant/G\nrecantation/S\nrecap\nrecappable\nrecapping\nrecast/G\nrecd\nrecede\nreceipt/SGDM\nreceivable/S\nreceive/ZGRSDB\nreceived/U\nreceiver/M\nreceivership/SM\nrecency/M\nrecension/M\nrecent/YPT\nrecentness/SM\nreceptacle/SM\nreception/MS\nreceptionist/MS\nreceptive/YP\nreceptiveness/S\nreceptivity/S\nreceptor/MS\nrecess/SDMVG\nrecessional/S\nrecessionary\nrecessive/YPS\nrecessiveness/M\nrechargeable\nrecheck/G\nrecherches\nrecherch\nrecidivism/MS\nrecidivist/MS\nrecipe/MS\nrecipiency\nrecipient/MS\nreciprocal/SY\nreciprocate/NGXVDS\nreciprocation/M\nreciprocity/MS\nrecital/MS\nrecitalist/S\nrecitative/MS\nrecite/ZR\nreciter/M\nrecked\nrecking\nreckless/PY\nrecklessness/S\nreckon/SGRDJ\nreckoner/M\nreckoning/M\nreclaim/B\nreclamation/SM\nrecline/RSDZG\nrecliner/M\nrecluse/MVNS\nreclusion/M\nrecode/G\nrecognizability\nrecognizable/U\nrecognizably\nrecognize/BZGSRD\nrecognized/U\nrecognizedly/S\nrecognizer/M\nrecognizing/UY\nrecognizingly/S\nrecoilless\nrecoinage\nrecolor/GD\nrecombinant\nrecombine\nrecommended/U\nrecompense/GDS\nrecompute/B\nreconcile/SRDGB\nreconciled/U\nreconciler/M\nrecondite/YP\nreconditeness/M\nreconfigurability\nreconfigure/R\nreconnaissance/MS\nreconnect/R\nreconnoiter/GSD\nreconquer/G\nreconsecrate\nreconstitute\nreconstructed/U\nreconsult/G\nrecontact/G\nrecontaminate/N\nrecontribute\nrecook/G\nrecopy/G\nrecord/ZGJ\nrecorded/AU\nrecords/A\nrecourse\nrecover/B\nrecoverability\nrecoverable/U\nrecovery/MS\nrecreant/S\nrecreational\nrecriminate/GNVXDS\nrecrimination/M\nrecriminatory\nrecross/G\nrecrudesce/GDS\nrecrudescence/MS\nrecrudescent\nrecruit/ZSGDRML\nrecruiter/M\nrecruitment/MS\nrecrystallize\nrecta's\nrectal/Y\nrectangle/SM\nrectangular/Y\nrectifiable\nrectification/M\nrectifier/M\nrectify/DRSGXZN\nrectilinear/Y\nrectitude/MS\nrecto/MS\nrector/SM\nrectory/MS\nrectum/SM\nrecumbent/Y\nrecuperate/VGNSDX\nrecuperation/M\nrecur\nrecurrence/MS\nrecurrent\nrecurse/NX\nrecursion/M\nrecusant/M\nrecuse\nrecyclable/S\nrecycle/BZ\nred/PYS\nredact/DGS\nredaction/SM\nredactor/MS\nredbird/SM\nredbreast/SM\nredbrick/M\nredbud/M\nredcap/MS\nredcoat/SM\nredcurrant/M\nredden/DGS\nredder\nreddest\nredding\nreddish/P\nredeclaration\nredecorate\nredeem/BRZ\nredeemable/U\nredeemed/U\nredeemer/M\nredemption/RMS\nredemptioner/M\nredemptive\nredeposit/M\nredetermination\nredhead/DRMS\nredial/G\nredirect/G\nredirection\nredlining/S\nredneck/SMD\nredness/MS\nredo/G\nredolence/MS\nredolent\nredouble/S\nredoubtably\nredound/GDS\nredshift/S\nredskin/SM\nreduce/RSDGZ\nreduced/U\nreducer/M\nreducibility/M\nreducible\nreducibly\nreduct/V\nreduction/SM\nreductionism/M\nreductionist/S\nredundancy/SM\nredundant/Y\nredwood/SM\nredye\nredyeing\nreecho/G\nreed/GMDR\nreediness/SM\nreeding/M\nreedy/PTR\nreef/GZSDRM\nreefer/M\nreek/GSR\nreeker/M\nreel's\nreel/USDG\nreeler/M\nreenforcement\nreentrant\nreestimate/M\nreeve/G\nreexamine\nref/ZS\nrefection/SM\nrefectory/SM\nrefer/B\nreferee/MSD\nrefereed/U\nrefereeing\nreference's\nreference/CGSRD\nreferenced/U\nreferencing/U\nreferendum/MS\nreferent/SM\nreferential/YM\nreferentiality\nreferral/SM\nreferred\nreferrer/S\nreferring\nreffed\nreffing\nrefile\nrefinance\nrefine/LZ\nrefined/U\nrefinement/MS\nrefinish/G\nrefit\nreflect/SDGV\nreflectance/M\nreflected/U\nreflection/SM\nreflectional\nreflective/YP\nreflectiveness/M\nreflectivity/M\nreflector/MS\nreflex/YV\nreflexion/MS\nreflexive/PSY\nreflexiveness/M\nreflexivity/M\nreflooring\nrefluent\nreflux/G\nrefocus/G\nrefold/G\nreforestation\nreforge/G\nreform/B\nreformatory/SM\nreformed/U\nreformer/M\nreformism/M\nreformist/S\nrefract/DGVS\nrefractive/PY\nrefractiveness/M\nrefractometer/MS\nrefractoriness/M\nrefractory/PS\nrefrain/DGS\nrefresh/LB\nrefreshed/U\nrefreshing/Y\nrefreshment/MS\nrefrigerant/MS\nrefrigerate/XDSGN\nrefrigerated/U\nrefrigeration/M\nrefrigerator/MS\nrefrozen\nrefry/GS\nrefuge/SDGM\nrefugee/MS\nrefulgence/SM\nrefulgent\nrefund/B\nrefunder/M\nrefurbish/L\nrefurbishment/S\nrefusal/SM\nrefuse/R\nrefuser/M\nrefutation/MS\nrefute/GZRSDB\nrefuter/M\nreg\nregal/GYRD\nregale/L\nregalement/S\nregalia/M\nregard/EGDS\nregardless/PY\nregather/G\nregatta/MS\nregency/MS\nregeneracy/MS\nregenerate/U\nregenerately\nregenerateness/M\nreggae/SM\nregicide/SM\nregime/MS\nregimen/MS\nregiment/SDMG\nregimental/S\nregimentation/MS\nregion/SM\nregional/SY\nregionalism/MS\nregister's\nregister/UDSG\nregistrable\nregistrant/SM\nregistrar/SM\nregistration/AM\nregistrations\nregistry/MS\nregnant\nregress/DSGV\nregression/MS\nregressive/PY\nregressiveness/M\nregressors\nregret/S\nregretful/PY\nregretfulness/M\nregrettable\nregrettably\nregretted\nregretting\nreground\nregroup/G\nregrow/G\nregular/YS\nregularity/MS\nregularization/MS\nregularize/SDG\nregulate/CSDXNG\nregulated/U\nregulation/M\nregulative\nregulator/SM\nregulatory\nregurgitate/XGNSD\nregurgitation/M\nrehab/S\nrehabbed\nrehabbing\nrehabilitate/SDXVGN\nrehabilitation/M\nrehang/G\nrehear/GJ\nrehears/R\nrehearsal/SM\nrehearse\nrehearsed/U\nrehearser/M\nreheat/G\nreheating/M\nrehydrate\nreign/MDSG\nreimburse/GSDBL\nreimbursement/MS\nrein/GDM\nreindeer/M\nreinforce/GSRDL\nreinforced/U\nreinforcement/MS\nreinforcer/M\nreinstate/L\nreinstatement/MS\nreinsurance\nreissue\nreiterative/SP\nreject/RDVGS\nrejecter/M\nrejecting/Y\nrejection/SM\nrejector/MS\nrejigger\nrejoice/RSDJG\nrejoicing/Y\nrejoinder/SM\nrejuvenate/NGSDX\nrejuvenatory\nrel/V\nrelapse\nrelate/XVNGSZ\nrelated/U\nrelatedly\nrelatedness/MS\nrelater/M\nrelation/M\nrelational/Y\nrelationship/MS\nrelative/SPY\nrelativeness/M\nrelativism/M\nrelativist/MS\nrelativistic\nrelativistically\nrelativity/MS\nrelator's\nrelax/GZD\nrelaxant/SM\nrelaxation/MS\nrelaxed/YP\nrelaxedness/M\nrelaxing/Y\nrelay/GDM\nrelearn/G\nreleasable/U\nrelease/B\nreleased/U\nrelent/SDG\nrelenting/U\nrelentless/PY\nrelentlessness/SM\nrelevance/SM\nrelevancy/MS\nrelevant/Y\nreliability/UMS\nreliable/U\nreliables\nreliably/U\nreliance/MS\nreliant/Y\nrelic/MS\nrelicense/R\nrelict's\nrelict/C\nrelief/M\nrelieve/RSDZG\nrelieved/U\nrelievedly\nreliever/M\nreligion/SM\nreligionists\nreligiosity/M\nreligious/PY\nreligiousness/MS\nrelink/G\nrelinquish/GSDL\nrelinquishment/SM\nreliquary/MS\nrelish/GSD\nrelive/GB\nreload/GR\nrelocate/B\nreluctance/MS\nreluctant/Y\nrely/DG\nrem\nremade/S\nremain/GD\nremainder/SGMD\nremake/M\nremand/DGS\nremap\nremapping\nremark/BG\nremarkable/U\nremarkableness/S\nremarkably\nremarked/U\nrematch/G\nremeasure/D\nremediable/P\nremediableness/M\nremedy/SDMG\nremember/GR\nremembered/U\nrememberer/M\nremembrance/MRS\nremembrancer/M\nreminisce/GSD\nreminiscence/SM\nreminiscent/Y\nremiss/YP\nremissness/MS\nremit/S\nremittance/MS\nremitted\nremitting/U\nremnant/MS\nremodel/G\nremolding\nremonstrant/MS\nremonstrate/SDXVNG\nremonstration/M\nremonstrative/Y\nremorse/SM\nremorseful/PY\nremorsefulness/M\nremorseless/YP\nremorselessness/MS\nremote/RPTY\nremoteness/MS\nremoulds\nremoval/MS\nremunerate/VNGXSD\nremunerated/U\nremuneration/M\nremunerative/YP\nremunerativeness/M\nrenaissance/S\nrenal\nrenaturation\nrend\nrend/RGZS\nrender/GJRD\nrenderer/M\nrendering/M\nrendezvous/DSMG\nrendition/GSDM\nrenegade/SDMG\nrenege/GZRSD\nreneger/M\nrenew/BG\nrenewal/MS\nrenewer/M\nrennet/MS\nrennin/SM\nrenounce/LGRSD\nrenouncement/MS\nrenouncer/M\nrenovate/NGXSD\nrenovation/M\nrenovator/SM\nrenown/SGDM\nrent/GZMDRS\nrental/SM\nrentaller\nrenter/M\nrenumber/G\nrenumeration\nrenunciate/VNX\nrenunciation/M\nreoccupy/G\nreopen/G\nreorganized/U\nrep/S\nrepack/G\nrepair/BZGR\nrepairable/U\nrepairer/M\nrepairman/M\nrepairmen\nrepairs/E\nrepaper\nreparable\nreparation/SM\nrepartee/MDS\nreparteeing\nrepartition/Z\nrepast/G\nrepatriate/SDXNG\nrepave\nrepeal/GR\nrepealer/M\nrepeat/RDJBZG\nrepeatability/M\nrepeatable/U\nrepeatably\nrepeated/Y\nrepeater/M\nrepel/S\nrepelled\nrepellent/SY\nrepelling/Y\nrepent/RDG\nrepentance/SM\nrepentant/SY\nrepertoire/SM\nrepertory/SM\nrepetition\nrepetitious/YP\nrepetitiousness/S\nrepetitive/PY\nrepetitiveness/MS\nrepine/R\nrepiner/M\nreplace/RL\nreplay/GM\nreplenish/LRSDG\nreplenishment/S\nreplete/SDPXGN\nrepleteness/MS\nrepletion/M\nreplica/SM\nreplicate/SDVG\nreplicator/S\nreplug\nreply/X\nrepopulate\nreported/Y\nreportorial/Y\nrepose/M\nreposeful\nrepository/MS\nreprehend/GDS\nreprehensibility/MS\nreprehensible/P\nreprehensibleness/M\nreprehensibly\nreprehension/MS\nrepresent/GB\nrepresentable/U\nrepresentational/Y\nrepresentative/SYMP\nrepresentativeness/M\nrepresentativity\nrepresented/U\nrepress/V\nrepression/SM\nrepressive/YP\nrepressiveness/M\nreprieve/GDS\nreprimand/SGMD\nreprint/M\nreprisal/MS\nreproach/GRSDB\nreproacher/M\nreproachful/YP\nreproachfulness/M\nreproaching/Y\nreprobate/N\nreprocess/G\nreproducibility/MS\nreproducible/S\nreproducibly\nreproductive/S\nreproof/G\nreprove/R\nreproving/Y\nreptile/SM\nreptilian/S\nrepublic/M\nrepublicanism/SM\nrepublish/G\nrepudiate/XGNSD\nrepudiation/M\nrepudiator/S\nrepugnance/MS\nrepugnant/Y\nrepulse/VNX\nrepulsion/M\nrepulsive/PY\nrepulsiveness/MS\nreputability/SM\nreputably/E\nreputation/SM\nrepute/ESB\nreputed/Y\nreputing\nrequest/G\nrequested/U\nrequiem/SM\nrequire/LR\nrequirement/MS\nrequisite/PNXS\nrequisiteness/M\nrequisition/GDRM\nrequisitioner/M\nrequital/MS\nrequite/RZ\nrequited/U\nrequiter/M\nreread/G\nrerecord/G\nrerouteing\nrerunning\nres/C\nrescale\nrescind/SDRG\nrescission/SM\nrescue/GZRSD\nreseal/BG\nresearch/MB\nreselect/G\nresemblant\nresemble/DSG\nresend/G\nresent/DSLG\nresentful/PY\nresentfulness/SM\nresentment/MS\nreserpine/MS\nreservation/MS\nreserved/UYP\nreservedness/UM\nreservednesses\nreservist/SM\nreservoir/MS\nreset/RDG\nresettle/L\nreshipping\nreshow/G\nreshuffle/M\nreside/G\nresidence/MS\nresidency/SM\nresident/SM\nresidential/Y\nresider/M\nresidua\nresidual/YS\nresiduary\nresidue/SM\nresiduum/M\nresignation/MS\nresigned/YP\nresilience/MS\nresiliency/S\nresilient/Y\nresin/D\nresinlike\nresinous\nresiny\nresist/RDZVGS\nresistance/SM\nresistant/U\nresistantly\nresistants\nresisted/U\nresistible\nresistibly\nresisting/U\nresistive/PY\nresistiveness/M\nresistivity/M\nresistless\nresistor/MS\nresize/G\nresold\nresole/G\nresoluble\nresolute/PYTRV\nresoluteness/MS\nresolvability/M\nresolvable/U\nresolved/U\nresolvent\nresonance/SM\nresonant/YS\nresonate/DSG\nresonator/MS\nresorption/MS\nresort/R\nresound/G\nresourceful/PY\nresourcefulness/SM\nresp\nrespect's/E\nrespect/BSDRMZGV\nrespectability/SM\nrespectable/SP\nrespectably\nrespected/E\nrespectful/EY\nrespectfulness/SM\nrespecting/E\nrespective/PY\nrespectiveness/M\nrespects/E\nrespell/G\nrespiration/MS\nrespirator/SM\nrespiratory/M\nresplendence/MS\nresplendent/Y\nrespond/SDRZG\nrespondent/MS\nresponse/RSXMV\nresponser/M\nresponsibility/MS\nresponsible/P\nresponsibleness/M\nresponsibly\nresponsive/YPU\nresponsiveness/MSU\nrespray/G\nrest's/U\nrest/DRSGVM\nrestart/B\nrestate/L\nrestaurant/SM\nrestaurateur/SM\nrested/U\nrester/M\nrestful/YP\nrestfuller\nrestfullest\nrestfulness/MS\nrestitution/SM\nrestive/PY\nrestiveness/SM\nrestless/YP\nrestlessness/MS\nrestorability\nrestoration/MS\nrestorative/PYS\nrestore/Z\nrestorer/M\nrestrained/UY\nrestraint/MS\nrestrict/DVGS\nrestricted/YU\nrestriction/SM\nrestrictive/U\nrestrictively\nrestrictiveness/MS\nrestrictives\nrestroom/SM\nrestructurability\nrestructure\nrests/U\nrestudy/M\nrestyle\nresubstitute\nresult/SGMD\nresultant/YS\nresume/SDBG\nresumption/MS\nresurface\nresurgence/MS\nresurgent\nresurrect/GSD\nresurrection/SM\nresurvey/G\nresuscitate/XSDVNG\nresuscitation/M\nresuscitator/MS\nretail/Z\nretain/LZGSRD\nretainer/M\nretake\nretaliate/VNGXSD\nretaliation/M\nretaliatory\nretard/ZGRDS\nretardant/SM\nretardation/SM\nretarder/M\nretch/SDG\nretention/SM\nretentive/YP\nretentiveness/S\nretentivity/M\nretest/G\nrethought\nreticence/S\nreticent/Y\nreticle/SM\nreticular\nreticulate/GNYXSD\nreticulation/M\nreticule/MS\nreticulum/M\nretina/SM\nretinal/S\nretinue/MS\nretire/L\nretiredness/M\nretiree/MS\nretirement/SM\nretiring/YP\nretort/GD\nretract/DG\nretractile\nretrench/L\nretrenchment/MS\nretributed\nretribution/MS\nretributive\nretrieval/SM\nretrieve/ZGDRSB\nretriever/M\nretro/SM\nretroactive/Y\nretrofire/GMSD\nretrofit/S\nretrofitted\nretrofitting\nretroflection\nretroflex/D\nretroflexion/M\nretrogradations\nretrograde/GYDS\nretrogress/SDVG\nretrogression/MS\nretrogressive/Y\nretrorocket/MS\nretrospect/SVGMD\nretrospection/MS\nretrospective/SY\nretrovirus/S\nretrovision\nretry/G\nretsina/SM\nreturnable/S\nreturned/U\nreturnee/SM\nretype\nreuse/B\nreutilization\nrev/ZM\nrevanchist\nreveal/JBG\nrevealed/U\nrevealing/U\nrevealingly\nreveille/MS\nrevel/SJRDGZ\nrevelation/MS\nrevelatory\nrevelry/MS\nrevenge/MGSRD\nrevenger/M\nrevenue/ZR\nrevenuer/M\nreverberant\nreverberate/XVNGSD\nreverberation/M\nrevere/GSD\nreverence/SRDGM\nreverencer/M\nreverend/SM\nreverent/Y\nreverential/Y\nreverie/SM\nrevers/M\nreversal/MS\nreverse/Y\nreverser/M\nreversibility/M\nreversible/S\nreversibly\nreversion/R\nreversioner/M\nrevert/RDVGS\nreverter/M\nrevertible\nrevet/L\nrevetment/SM\nreview/G\nrevile/GZSDL\nrevilement/MS\nreviler/M\nrevise/BRZ\nrevised/U\nrevisionary\nrevisionism/SM\nrevisionist/SM\nrevitalize/ZR\nrevival/SM\nrevivalism/MS\nrevivalist/MS\nrevive/RSDG\nreviver/M\nrevivification/M\nrevivify/X\nrevocable\nrevoke/GZRSD\nrevolt/GRD\nrevolter/M\nrevolting/Y\nrevolution/SM\nrevolutionariness/M\nrevolutionary/MSP\nrevolutionist/MS\nrevolutionize/GDSRZ\nrevolutionizer/M\nrevolve/BSRDZJG\nrevolver/M\nrevue/MS\nrevulsion/MS\nrevved\nrevving\nrewarded/U\nrewarding/Y\nrewarm/G\nreweave\nrewedding\nreweigh/G\nrewind/BGR\nrewire/G\nrework/G\nrexes\nrezone\nrhapsodic\nrhapsodical\nrhapsodize/GSD\nrhapsody/SM\nrhea/SM\nrhenium/MS\nrheology/M\nrheostat/MS\nrhesus/S\nrhetoric/MS\nrhetorical/YP\nrhetorician/MS\nrheum/MS\nrheumatic/S\nrheumatically\nrheumatics/M\nrheumatism/SM\nrheumatoid\nrheumy/RT\nrhinestone/SM\nrhinitides\nrhinitis/M\nrhino/MS\nrhinoceros/MS\nrhinotracheitis\nrhizome/MS\nrho/MS\nrhodium/MS\nrhododendron/SM\nrhodolite/M\nrhodonite/M\nrhombic\nrhomboid/SM\nrhomboidal\nrhombus/SM\nrhubarb/MS\nrhyme/DSRGZM\nrhymester/MS\nrhythm/MS\nrhythmic/S\nrhythmical/Y\nrhythmics/M\nrial/MS\nrib/MS\nribald/S\nribaldry/MS\nribbed\nribber/S\nribbing/M\nribbon/DMSG\nribcage\nriboflavin/MS\nribonucleic\nribosomal\nribosome/MS\nrice/DRSMZG\nricer/M\nrich/YNSRPT\nrichen/DG\nrichness/MS\nrick/GSDM\nrickets/M\nrickety/RT\nrickrack/MS\nrickshaw/SM\nricochet/GSD\nricotta/MS\nrid/ZGRJSB\nriddance/SM\nridden\nridding\nriddle/GMRSD\nride/CZSGR\nrider/CM\nriderless\nridership/S\nridge/DSGM\nridgepole/SM\nridgy/RT\nridicule/MGDRS\nridiculer/M\nridiculous/PY\nridiculousness/MS\nriding/M\nrife/RT\nriff/GSDM\nriffle/SDG\nriffraff/SM\nrifle/GZMDSR\nrifled/U\nrifleman/M\nriflemen\nrifler/M\nrifling/M\nrift/GSMD\nrig/MS\nrigamarole's\nrigatoni/M\nrigged\nrigger/SM\nrigging/MS\nright/SGTPYRDN\nrighteous/PYU\nrighteousness/MS\nrighteousnesses/U\nrightful/PY\nrightfulness/MS\nrightism/SM\nrightist/S\nrightmost\nrightness/MS\nrights/M\nrightsize/SDG\nrightward/S\nrigid/YP\nrigidify/S\nrigidity/S\nrigidness/S\nrigmarole/MS\nrigor/MS\nrigorous/YP\nrigorousness/S\nrile/DSG\nrill/GSMD\nrim/GSMDR\nrime/MS\nrimer/M\nrimless\nrimmed\nrimming\nrind/MDGS\nring/GZJDRM\nringer/M\nringing/Y\nringleader/MS\nringlet/SM\nringlike\nringmaster/MS\nringside/ZMRS\nringworm/SM\nrink/GDRMS\nrinse/DSRG\nriot/SMDRGZJ\nrioter/M\nriotous/PY\nriotousness/M\nrip/NDRSXTG\nriparian/S\nripcord/SM\nripe/PSY\nripen/RDG\nripened/U\nripeness/UM\nripenesses\nriper/U\nripest/U\nripoff/S\nriposte/SDMG\nripped\nripper/SM\nripping\nripple/RSDGM\nrippler/M\nripply/TR\nripsaw/GDMS\nriptide/SM\nrise/RSJZG\nrisen\nriser/M\nrisibility/SM\nrisible/S\nrising/M\nrisk/GSDRM\nrisker/M\nriskily\nriskiness/MS\nrisky/RTP\nrisotto/SM\nrisqu\nrissole/M\nrite/DSM\nritual/MSY\nritualism/SM\nritualistic\nritualistically\nritualized\nritzy/TR\nriv/ZGNDR\nrival/SGDM\nrivaled/U\nrivalry/MS\nrive/CSGRD\nriver/CM\nriverbank/SM\nriverbed/S\nriverboat/S\nriverfront\nriverine\nriverside/S\nrivet/GZSRDM\nriveter/M\nriveting/Y\nrivulet/SM\nriyal/SM\nrm\nroach/GSDM\nroad/MIS\nroadbed/MS\nroadblock/SMDG\nroadhouse/SM\nroadie/S\nroadkill/S\nroadrunner/MS\nroadshow/S\nroadside/S\nroadsigns\nroadster/SM\nroadsweepers\nroadway/SM\nroadwork/SM\nroadworthy\nroam/DRGZS\nroan/S\nroar/DRSJGZ\nroarer/M\nroaring/T\nroast/SGJZRD\nroaster/M\nrob/SDG\nrobbed\nrobber/SM\nrobbery/SM\nrobbing\nrobe's\nrobe/ESDG\nrobin/MS\nrobot/MS\nrobotic/S\nrobotism\nrobotize/GDS\nrobust/RYPT\nrobustness/SM\nrock/GZDRMS\nrockabilly/MS\nrockabye\nrockbound\nrocker/M\nrocket/SMDG\nrocketry/MS\nrockfall/S\nrockiness/MS\nrocky/SRTP\nrococo/MS\nrod/SGMD\nrodded\nrodder\nrodding\nrode/S\nrodent/MS\nrodeo/SMDG\nroe/SM\nroebuck/SM\nroentgen/SM\nroger/GSD\nrogue/GMDS\nrogued/K\nroguery/MS\nrogues/K\nroguing/K\nroguish/PY\nroguishness/SM\nroil/SGD\nroister/SZGRD\nroisterer/M\nrole/MS\nroll/UDSG\nrollback/SM\nrolled/A\nroller/SM\nrollerskating\nrollick/DGS\nrollicking/Y\nrolling/S\nrollover/S\nromaine/MS\nroman/S\nromance/RSDZMG\nromancer/M\nromantic/MS\nromantically/U\nromanticism/MS\nromanticist/S\nromanticize/SDG\nromeo/S\nromp/GSZDR\nromper/M\nrondo/SM\nrood/MS\nroof/DRMJGZS\nroofer/M\nroofgarden\nroofing/M\nroofless\nrooftop/S\nrook/GDMS\nrookery/MS\nrookie/SRMT\nroom/MDRGZS\nroomer/M\nroomette/SM\nroomful/MS\nroominess/MS\nroommate/SM\nroomy/TPSR\nroost/SGZRDM\nrooster/M\nroot/MGDRZS\nrooted/P\nrooter/M\nrootless/P\nrootlessness/M\nrootlet/SM\nrootstock/M\nrope/DRSMZG\nroper/M\nroping/M\nrosary/SM\nrose/MGDS\nroseate/Y\nrosebud/MS\nrosebush/SM\nrosemary/MS\nrosette/SDMG\nrosewater\nrosewood/SM\nrosily\nrosin/SMDG\nrosiness/MS\nroster/DMGS\nrostra's\nrostrum/SM\nrosy/RTP\nrot/SDG\nrota/MS\nrotary/S\nrotate/VGNXSD\nrotated/U\nrotation/M\nrotational/Y\nrotative/Y\nrotator/SM\nrotatory\nrote/MS\nrotgut/MS\nrotisserie/MS\nrotogravure/SM\nrotor/MS\nrototill/RZ\nrotted\nrotten/RYSTP\nrottenness/S\nrotter/M\nrotting\nrotund/SDYPG\nrotunda/SM\nrotundity/S\nrotundness/S\nrouge/GMDS\nrough/XPYRDNGT\nroughage/SM\nroughen/DG\nrougher/M\nroughhouse/GDSM\nroughish\nroughneck/MDSG\nroughness/MS\nroughs\nroughshod\nroulette/MGDS\nround/YRDSGPZT\nroundabout/PSM\nrounded/P\nroundedness/M\nroundelay/SM\nroundels\nrounder/M\nroundhead/D\nroundheaded/P\nroundheadedness/M\nroundhouse/SM\nroundish\nroundness/MS\nroundoff\nroundup/MS\nroundworm/MS\nrouse/DSRG\nrouser/M\nroust/SGD\nroustabout/SM\nrout/GZJMDRS\nroute's\nroute/ASRDZGJ\nrouter/M\nroutine/SYM\nrouting/M\nroutinize/GSD\nrou/MS\nrove/ZGJDRS\nrover/M\nroving/M\nrow/SJZMGNDR\nrowboat/SM\nrowdily\nrowdiness/MS\nrowdy/PTSR\nrowdyism/MS\nrowel/DMSG\nrowen/M\nrower/M\nroyal/SY\nroyalist/SM\nroyalty/MS\nrpm\nrps\nrs\nrt\nrte\nrub/S\nrubato/MS\nrubbed\nrubber/SDMG\nrubberize/GSD\nrubberneck/DRMGSZ\nrubbery/TR\nrubbing/M\nrubbish/DSMG\nrubbishy\nrubble/GMSD\nrubdown/MS\nrube/SM\nrubella/MS\nrubicund\nrubidium/SM\nruble/MS\nrubout\nrubric/MS\nruby/MTGDSR\nruck/M\nrucksack/SM\nruckus/SM\nruction/SM\nrudder/MS\nrudderless\nruddiness/MS\nruddy/PTGRSD\nrude/PYTR\nrudeness/MS\nrudiment/SM\nrudimentariness/M\nrudimentary/P\nrue/GDS\nrueful/PY\nruefulness/S\nruff/GSYDM\nruffian/GSMDY\nruffle/RSDG\nruffled/U\nruffler/M\nruffly/TR\nrug/MS\nrugby/SM\nrugged/PYRT\nruggedness/S\nrugging\nruin/MGSDR\nruination/MS\nruiner/M\nruinous/YP\nruinousness/M\nrule/MZGJDRS\nrulebook/S\nruled/U\nruler/GMD\nruling/M\nrum/XSMN\nrumba/GDMS\nrumble/JRSDG\nrumbler/M\nrumbustious\nrumen/M\nruminant/YMS\nruminate/VNGXSD\nruminative/Y\nrummage/GRSD\nrummager/M\nrummer\nrummest\nrummy/TRSM\nrumor/ZMRDSG\nrumored/U\nrumorer/M\nrumormonger/SGMD\nrump/GMYDS\nrumple/SDG\nrumply/TR\nrumpus/SM\nrun/AS\nrunabout/SM\nrunaround/S\nrunaway/S\nrundown/SM\nrune/MS\nrung/MS\nrunic\nrunlet/SM\nrunnable\nrunnel/SM\nrunner/MS\nrunning/S\nrunny/RT\nrunoff/MS\nrunt/MS\nruntime\nruntiness/M\nrunty/RPT\nrunway/MS\nrupee/MS\nrupiah/M\nrupiahs\nrupture/GMSD\nrural/Y\nrurality/M\nruse/MS\nrush/DSRGZ\nrusher/M\nrushes/I\nrushing/M\nrushy/RT\nrusk/MS\nrusset/MDS\nrussetting\nrust/MSDG\nrustic/S\nrustically\nrusticate/GSD\nrustication/M\nrusticity/S\nrustiness/MS\nrustle/RSDGZ\nrustler/M\nrustproof/DGS\nrusty/XNRTP\nrut/MS\nrutabaga/SM\nruthenium/MS\nrutherfordium/SM\nruthless/YP\nruthlessness/MS\nrutted\nrutting\nrutty/RT\nrye/MS\ns's/KI\ns/XJBG\nsabbath\nsabbatical/S\nsaber/GSMD\nsabered/U\nsable/GMDS\nsabot/MS\nsabotage/DSMG\nsaboteur/SM\nsabra/MS\nsac/SM\nsaccharides\nsaccharin/MS\nsaccharine\nsacerdotal\nsachem/MS\nsachet/SM\nsack/GJDRMS\nsackcloth/M\nsackcloths\nsacker/M\nsackful/MS\nsacking/M\nsacra/L\nsacral\nsacrament/DMGS\nsacramental/S\nsacred/PY\nsacredness/S\nsacrifice/RSDZMG\nsacrificer/M\nsacrificial/Y\nsacrilege/MS\nsacrilegious/Y\nsacristan/SM\nsacristy/MS\nsacroiliac/S\nsacrosanct/P\nsacrosanctness/MS\nsacrum/M\nsad/PY\nsadden/DSG\nsadder\nsaddest\nsaddle's\nsaddle/UGDS\nsaddlebag/SM\nsaddler/M\nsades\nsadism/MS\nsadist/MS\nsadistic\nsadistically\nsadness/SM\nsadomasochism/MS\nsadomasochist/S\nsadomasochistic\nsafari/GMDS\nsafe/URPTY\nsafeguard/MDSG\nsafekeeping/MS\nsafeness's/U\nsafeness/MS\nsafes\nsafety/SDMG\nsafflower/SM\nsaffron/MS\nsag/TSR\nsaga/MS\nsagacious/YP\nsagaciousness/M\nsagacity/MS\nsage/MYPS\nsagebrush/SM\nsagged\nsagger\nsagging\nsaggy/RT\nsago/MS\nsaguaro/SM\nsahib/MS\nsaid/U\nsaids\nsail/GJMDRS\nsailboard/DGS\nsailboat/SRMZG\nsailcloth/M\nsailcloths\nsailer/M\nsailfish/SM\nsailing/M\nsailor/YMS\nsailplane/SDMG\nsaint/YDMGS\nsainthood/MS\nsaintlike\nsaintliness/MS\nsaintly/RTP\nsaith\nsaiths\nsake/MRS\nsaker/M\nsaki's\nsalaam/GMDS\nsalable/U\nsalacious/YP\nsalaciousness/MS\nsalacity/MS\nsalad/SM\nsalamander/MS\nsalami/MS\nsalary/SDMG\nsale/ABMS\nsaleability/M\nsalesclerk/SM\nsalesgirl/SM\nsaleslady/S\nsalesman/M\nsalesmanship/SM\nsalesmen\nsalespeople/M\nsalesperson/MS\nsalesroom/M\nsaleswoman\nsaleswomen\nsalience/MS\nsaliency\nsalient/SY\nsaline/S\nsalinger\nsalinity/MS\nsaliva/MS\nsalivary\nsalivate/XNGSD\nsalivation/M\nsallow/TGRDSP\nsallowness/MS\nsally/GSDM\nsalmon/SM\nsalmonella/M\nsalmonellae\nsalon/SM\nsaloon/MS\nsaloonkeeper\nsalsa/MS\nsalsify/M\nsalt/GZTPMDRS\nsaltcellar/SM\nsalted/UC\nsalter/M\nsaltine/MS\nsaltiness/SM\nsaltness/M\nsaltpeter/SM\nsalts/C\nsaltshaker/S\nsaltwater\nsalty/RSPT\nsalubrious/YP\nsalubriousness/M\nsalubrity/M\nsalutariness/M\nsalutary/P\nsalutation/SM\nsalutatory/S\nsalute/RSDG\nsaluter/M\nsalvage/MGRSD\nsalvageable\nsalvager/M\nsalvation/MS\nsalve/GZMDSR\nsalver/M\nsalvo/GMDS\nsamarium/MS\nsamba/GSDM\nsame/SP\nsameness/MS\nsamovar/SM\nsampan/MS\nsample/RSDJGMZ\nsampler/M\nsampling/M\nsamurai/M\nsanatorium/MS\nsanctification/M\nsanctifier/M\nsanctify/RSDGNX\nsanctimonious/PY\nsanctimoniousness/MS\nsanctimony/MS\nsanction/SMDG\nsanctioned/U\nsanctity/SM\nsanctuary/MS\nsanctum/SM\nsand/SMDRGZ\nsandal/MDGS\nsandalwood/SM\nsandbag/MS\nsandbagged\nsandbagging\nsandbank/SM\nsandbar/S\nsandblast/GZSMRD\nsandblaster/M\nsandbox/MS\nsandcastle/S\nsander/M\nsandhill\nsandhog/SM\nsandiness/S\nsandlot/SM\nsandlotter/S\nsandman/M\nsandmen\nsandpaper/DMGS\nsandpile\nsandpiper/MS\nsandpit/M\nsandstone/MS\nsandstorm/SM\nsandwich/SDMG\nsandy/PRT\nsane/IRYTP\nsaned\nsaneness's/I\nsaneness/MS\nsanes\nsang/S\nsangfroid/S\nsangria/SM\nsanguinary\nsanguine/F\nsanguined\nsanguinely\nsanguineness/M\nsanguineous/F\nsanguines\nsanguining\nsaning\nsanitarian/S\nsanitarium/SM\nsanitary/S\nsanitate/NX\nsanitation/M\nsanitize/RSDZG\nsanitizer/M\nsanity/SIM\nsank\nsans\nsanserif\nsap/MS\nsapience/MS\nsapient\nsapless\nsapling/SM\nsapped\nsapper/SM\nsapphire/MS\nsappiness/SM\nsapping\nsappy/RPT\nsaprophyte/MS\nsaprophytic\nsapsucker/SM\nsapwood/SM\nsaran/SM\nsarape's\nsarcasm/MS\nsarcastic\nsarcastically\nsarcoma/MS\nsarcophagi\nsarcophagus/M\nsardine/SDMG\nsardonic\nsardonically\nsarge/SM\nsari/MS\nsarong/MS\nsarsaparilla/MS\nsartorial/Y\nsartorius/M\nsash/GMDS\nsashay/GDS\nsass/GDSM\nsassafras/MS\nsassy/TRS\nsat/DG\nsatanic\nsatanical/Y\nsatanism/S\nsatanist/S\nsatchel/SM\nsate/S\nsateen/MS\nsatellite/GMSD\nsatiable/I\nsatiate/GNXSD\nsatiation/M\nsatiety/MS\nsatin/MDSG\nsatinwood/MS\nsatiny\nsatire/SM\nsatiric\nsatirical/Y\nsatirist/SM\nsatirize/DSG\nsatirizes/U\nsatisfaction/ESM\nsatisfactorily/U\nsatisfactoriness/MU\nsatisfactory/UP\nsatisfiability/U\nsatisfiable/U\nsatisfied/UE\nsatisfier/M\nsatisfies/E\nsatisfy/GZDRS\nsatisfying/EU\nsatisfyingly\nsatori/SM\nsatrap/SM\nsaturate/XDRSNG\nsaturated/CUA\nsaturater/M\nsaturates/A\nsaturation/M\nsaturnalia\nsaturnine/Y\nsatyr/MS\nsatyriases\nsatyriasis/M\nsatyric\nsauce/DSRGZM\nsaucepan/SM\nsaucer/M\nsaucily\nsauciness/S\nsaucy/TRP\nsauerkraut/SM\nsauna/DMSG\nsaunter/DRSG\nsaurian/S\nsauropod/SM\nsausage/MS\nsaut/DGS\nsavage/GTZYPRSD\nsavageness/SM\nsavagery/MS\nsavanna/MS\nsavant/SM\nsave/ZGJDRSB\nsaved/U\nsaveloy/M\nsaver/M\nsavior/SM\nsavor/SMRDGZ\nsavored/U\nsavorer/M\nsavorier\nsavoriest\nsavoriness/S\nsavoring/Y\nsavoringly/S\nsavory/UMPS\nsavoy/SM\nsavvy/GTRSD\nsaw/SMDRG\nsawbones/M\nsawbuck/SM\nsawdust/MDSG\nsawer/M\nsawfly/SM\nsawhorse/MS\nsawmill/SM\nsawtooth\nsawyer/MS\nsax/MS\nsaxifrage/SM\nsaxophone/MS\nsaxophonist/SM\nsay/USG\nsayer/SM\nsayest\nsaying/MS\nsays/M\nscab/SM\nscabbard/SGDM\nscabbed\nscabbiness/SM\nscabbing\nscabby/RTP\nscabies/M\nscabrous/YP\nscabrousness/M\nscad/SM\nscaffold/JGDMS\nscaffolding/M\nscalability\nscalar/SM\nscalawag/SM\nscald/GJRDS\nscale/JGZMBDSR\nscaled/AU\nscaleless\nscalene\nscaler/M\nscales/A\nscaliness/MS\nscaling/A\nscallion/MS\nscallop/GSMDR\nscalloper/M\nscalloping/M\nscalp/GZRDMS\nscalpel/SM\nscalper/M\nscalping/M\nscaly/TPR\nscam/SM\nscammed\nscamming\nscamp/RDMGZS\nscamper/GD\nscampi/M\nscan/AS\nscandal/GMDS\nscandalize/GDS\nscandalized/U\nscandalmonger/SM\nscandalous/YP\nscandalousness/M\nscandium/MS\nscanned/A\nscanner/SM\nscanning/A\nscansion/SM\nscant/CDRSG\nscantest\nscantily\nscantiness/MS\nscantly\nscantness/MS\nscanty/TPRS\nscape/M\nscapegoat/SGDM\nscapegrace/MS\nscapula/M\nscapulae\nscapular/S\nscar/DRMSG\nscarab/SM\nscarce/RTYP\nscarceness/SM\nscarcity/MS\nscare/S\nscarecrow/MS\nscaremonger/SGM\nscaremongering/M\nscarer/M\nscarf/SDGM\nscarface\nscarification/M\nscarify/DRSNGX\nscarily\nscariness/S\nscarlatina/MS\nscarlet/MDSG\nscarp/SDMG\nscarred\nscarring\nscarves/M\nscary/PTR\nscat/S\nscathe/DG\nscathed/U\nscathing/Y\nscatological\nscatology/SM\nscatted\nscatter/DRJZSG\nscatterbrain/MDS\nscatterer/M\nscattergun\nscattering/YM\nscatting\nscavenge/GDRSZ\nscavenger/M\nscenario/SM\nscenarist/MS\nscene/GMDS\nscenery/SM\nscenic/S\nscenically\nscent's/C\nscent/GDMS\nscented/U\nscentless\nscents/C\nscepter/DMSG\nscepters/U\nsceptically\nsch\nschedule's\nschedule/ADSRG\nscheduled/U\nscheduler/MS\nschema/M\nschemata\nschematic/S\nschematically\nscheme/JSRDGMZ\nschemer/M\nschemta\nscherzo/MS\nschilling/SM\nschism/SM\nschismatic/S\nschist/SM\nschizo/S\nschizoid/S\nschizomycetes\nschizophrenia/SM\nschizophrenic/S\nschizophrenically\nschlemiel/MS\nschlep/S\nschlepped\nschlepping\nschlock/SM\nschlocky/TR\nschmaltz/MS\nschmaltzy/TR\nschmo/M\nschmoes\nschmooze/GSD\nschmuck/MS\nschnapps/M\nschnauzer/MS\nschnitzel/MS\nschnook/SM\nschnoz/S\nschnozzle/MS\nscholar/SYM\nscholarship/MS\nscholastic/S\nscholastically\nschool/ZGMRDJS\nschoolbag/SM\nschoolbook/SM\nschoolboy/MS\nschoolchild/M\nschoolchildren\nschooldays\nschooled/U\nschoolfellow/S\nschoolfriend\nschoolgirl/MS\nschoolgirlish\nschoolhouse/MS\nschooling/M\nschoolmarm/MS\nschoolmarmish\nschoolmaster/SGDM\nschoolmate/MS\nschoolmistress/MS\nschoolroom/SM\nschoolteacher/MS\nschoolwork/SM\nschoolyard/SM\nschooner/SM\nschuss/SDMG\nschussboomer/S\nschwa/SM\nsci\nsciatic/S\nsciatica/SM\nscience/FMS\nscientific/U\nscientifically/U\nscientist/SM\nscimitar/SM\nscintilla/MS\nscintillate/GNDSX\nscintillation/M\nscintillator/SM\nscion/SM\nscissor/SGD\nscleroses\nsclerosis/M\nsclerotic/S\nscoff/RDGZS\nscoffer/M\nscofflaw/MS\nscold/GSJRD\nscolder/M\nscolioses\nscoliosis/M\nscollop's\nsconce/SDGM\nscone/SM\nscoop/SRDMG\nscooper/M\nscoot/SRDGZ\nscooter/M\nscope/DSGM\nscops\nscorbutic\nscorch/ZGRSD\nscorcher/M\nscorching/Y\nscore/ZMDSRJG\nscoreboard/MS\nscorecard/MS\nscored/M\nscorekeeper/SM\nscoreless\nscoreline\nscorn/SGZMRD\nscorner/M\nscornful/PY\nscornfulness/M\nscorpion/SM\nscotch/MSDG\nscotchs\nscoundrel/YMS\nscour/SRDGZ\nscourer/M\nscourge/MGRSD\nscourger/M\nscouring/M\nscout/SRDMJG\nscouter/M\nscouting/M\nscoutmaster/SM\nscow/DMGS\nscowl/SRDG\nscowler/M\nscrabble/DRSZG\nscrabbler/M\nscrag/SM\nscragged\nscragging\nscraggly/TR\nscraggy/TR\nscram/S\nscramble/UDSRG\nscrambler's/U\nscrambler/MS\nscrammed\nscramming\nscrap/SGZJRDM\nscrapbook/SM\nscrape/S\nscraper/M\nscrapheap/SM\nscrapped\nscrapper/SM\nscrapping\nscrappy/RT\nscrapyard/S\nscratch/JDRSZG\nscratched/U\nscratcher/M\nscratches/M\nscratchily\nscratchiness/S\nscratchy/TRP\nscrawl/GRDS\nscrawler/M\nscrawly/RT\nscrawniness/MS\nscrawny/TRP\nscream/ZGSRD\nscreamer/M\nscreaming/Y\nscree/DSM\nscreech/GMDRS\nscreecher/M\nscreechy/TR\nscreed/MS\nscreen/RDMJSG\nscreened/U\nscreening/M\nscreenplay/MS\nscreenwriter/MS\nscrew's\nscrew/GUSD\nscrewball/SM\nscrewdriver/SM\nscrewer/M\nscrewiness/S\nscrewup\nscrewworm/MS\nscrewy/RTP\nscribal\nscribble/JZDRSG\nscribbler/M\nscribe's\nscribe/CDRSGIK\nscriber/MKIC\nscrim/SM\nscrimmage/RSDMG\nscrimmager/M\nscrimp/DGS\nscrimshaw/GSDM\nscrip/SM\nscript/FGMDS\nscripted/U\nscriptural/Y\nscripture/MS\nscriptwriter/SM\nscriptwriting/M\nscriven/ZR\nscrivener/M\nscrod/M\nscrofula/MS\nscrofulous\nscroll/GMDSB\nscrollbar/SM\nscrooge/SDMG\nscrota\nscrotal\nscrotum/M\nscrounge/ZGDRS\nscroungy/TR\nscrub/S\nscrubbed\nscrubber/MS\nscrubbing\nscrubby/TR\nscruff/SM\nscruffily\nscruffiness/S\nscruffy/PRT\nscrum/MS\nscrummage/MG\nscrumptious/Y\nscrunch/DSG\nscrunchy/S\nscruple/SDMG\nscrupulosity/SM\nscrupulous/UPY\nscrupulousness's\nscrupulousness/US\nscrutable/I\nscrutinize/RSDGZ\nscrutinized/U\nscrutinizer/M\nscrutinizing/UY\nscrutinizingly/S\nscrutiny/MS\nscuba/SDMG\nscud/S\nscudded\nscudding\nscuff/GSD\nscuffle/SDG\nscull/SRDMGZ\nsculler/M\nscullery/MS\nscullion/MS\nsculpt/SDG\nsculptor/MS\nsculptress/MS\nsculptural/Y\nsculpture/SDGM\nscum/MS\nscumbag/S\nscummed\nscumming\nscummy/TR\nscupper/SDMG\nscurf/MS\nscurfy/TR\nscurrility/MS\nscurrilous/PY\nscurrilousness/MS\nscurry/GJSD\nscurvily\nscurviness/M\nscurvy/SRTP\nscutcheon/SM\nscuttle/MGSD\nscuttlebutt/MS\nscuzzy/RT\nscythe/SDGM\nsea/MYS\nseabed/S\nseabird/S\nseaboard/MS\nseaborne\nseacoast/MS\nseafare/JRZG\nseafarer/M\nseafood/MS\nseafront/MS\nseagoing\nseagull/S\nseahorse/S\nseal/MDRSGZ\nsealant/MS\nsealed/AU\nsealer/M\nseals/UA\nsealskin/SM\nseam/MNDRGS\nseamail\nseaman/YM\nseamanship/SM\nseamer/M\nseaminess/M\nseamless/PY\nseamlessness/M\nseams/I\nseamstress/MS\nseamy/TRP\nseaplane/SM\nseaport/SM\nseaquake/M\nsear/DRSJGT\nsearch/RSDAGZ\nsearcher/AM\nsearching/YS\nsearchlight/SM\nsearing/Y\nseascape/SM\nseashell/MS\nseashore/SM\nseasick/P\nseasickness/SM\nseaside/SM\nseason/JRDYMBZSG\nseasonable/UP\nseasonableness/M\nseasonably/U\nseasonal/Y\nseasonality\nseasoned/U\nseasoner/M\nseasoning/M\nseat's\nseat/UDSG\nseatbelt\nseated/A\nseater/M\nseating/SM\nseawall/S\nseaward/S\nseawater/S\nseaway/MS\nseaweed/SM\nseaworthiness/MU\nseaworthinesses\nseaworthy/TRP\nsebaceous\nseborrhea/SM\nsec'y\nsec/S\nsecant/SM\nsecede/GRSD\nsecession/MS\nsecessionist/MS\nseclude/GSD\nsecluded/YP\nsecludedness/M\nseclusion/SM\nseclusive\nsecond/RDYZGSL\nsecondarily\nsecondary/PS\nseconder/M\nsecondhand\nsecrecy/MS\nsecret/TVGRDYS\nsecretarial\nsecretariat/MS\nsecretary/SM\nsecretaryship/MS\nsecrete/XNS\nsecretion/M\nsecretive/PY\nsecretiveness/S\nsecretory\nsect/ISM\nsectarian/S\nsectarianism/MS\nsectary/MS\nsection/ASEM\nsectional/SY\nsectionalism/MS\nsectionalized\nsectioned\nsectioning\nsector/EMS\nsectoral\nsectored\nsectoring\nsects/E\nsecular/SY\nsecularism/MS\nsecularist/MS\nsecularity/M\nsecularization/MS\nsecularize/GSD\nsecularized/U\nsecure/PGTYRSDJ\nsecured/U\nsecurely/I\nsecurity/MSI\nsecy\nsedan/SM\nsedate/PXVNGTYRSD\nsedateness/SM\nsedation/M\nsedative/S\nsedentary\nsedge/SM\nsedgy/RT\nsediment/SGDM\nsedimentary\nsedimentation/SM\nsedition/SM\nseditious/PY\nseditiousness/M\nseduce/RSDGZ\nseducer/M\nseduction/MS\nseductive/YP\nseductiveness/MS\nseductress/SM\nsedulous/Y\nsee/U\nseed's\nseed/ADSG\nseedbed/MS\nseedcase/SM\nseeded/U\nseeder/MS\nseediness/MS\nseeding/S\nseedless\nseedling/SM\nseedpod/S\nseedy/TPR\nseeing's\nseeing/U\nseeings\nseek/GZSR\nseeker/M\nseeking/Y\nseem/GJSYD\nseeming/Y\nseemliness's\nseemliness/US\nseemly/UTPR\nseen/U\nseep/GSD\nseepage/MS\nseer/SM\nseersucker/MS\nsees\nseesaw/DMSG\nseethe/SDGJ\nsegment/SGDM\nsegmental/Y\nsegmentation/SM\nsegmented/U\nsegregant\nsegregate/XCNGSD\nsegregated/U\nsegregation/CM\nsegregationist/SM\nsegregative\nsegue/DS\nsegueing\nseigneur/MS\nseignior/SM\nseine/GZMDSR\nseiner/M\nseismic\nseismically\nseismograph/ZMR\nseismographer/M\nseismographic\nseismographs\nseismography/SM\nseismologic\nseismological\nseismologist/MS\nseismology/SM\nseismometer/S\nseize/BJGZDSR\nseizer/M\nseizin/MS\nseizing/M\nseizor/MS\nseizure/MS\nseldom\nselect/PDSVGB\nselected/UAC\nselection/MS\nselectional\nselective/YP\nselectiveness/M\nselectivity/MS\nselectman/M\nselectmen\nselectness/SM\nselector/SM\nselects/A\nselenate/M\nselenite/M\nselenium/MS\nselenographer/SM\nselenography/MS\nself/GPDMS\nselfish/PUY\nselfishness/SU\nselfless/YP\nselflessness/MS\nselfness/M\nselfsame/P\nselfsameness/M\nsell/AZGSR\nseller/AM\nsellout/MS\nseltzer/S\nselvage/MGSD\nselves/M\nsemantic/S\nsemantical/Y\nsemanticist/SM\nsemantics/M\nsemaphore/GMSD\nsemblance/ASME\nsemen/SM\nsemester/SM\nsemi/SM\nsemiannual/Y\nsemiarid\nsemiautomated\nsemiautomatic/S\nsemicircle/SM\nsemicircular\nsemicolon/MS\nsemiconductor/SM\nsemiconscious\nsemidefinite\nsemidetached\nsemidrying/M\nsemifinal/MS\nsemifinalist/MS\nsemilogarithmic\nsemimonthly/S\nseminal/Y\nseminar/SM\nseminarian/MS\nseminary/MS\nsemiofficial\nsemiotic/S\nsemioticians\nsemiotics/M\nsemipermanent/Y\nsemipermeable\nsemiprecious\nsemiprivate\nsemiprofessional/YS\nsemipublic\nsemiquantitative/Y\nsemiretired\nsemisecret\nsemiskilled\nsemisolid/S\nsemistructured\nsemisweet\nsemitic/S\nsemitone/SM\nsemitrailer/SM\nsemitrance\nsemitransparent\nsemitropical\nsemivowel/MS\nsemiweekly/S\nsemiyearly\nsemolina/SM\nsempiternal\nsempstress/SM\nsen\nsenate/MS\nsenator/MS\nsenatorial\nsend/SRGZ\nsender/M\nsends/A\nsenescence/SM\nsenescent\nsenile/SY\nsenility/MS\nsenior/MS\nseniority/SM\nsenna/MS\nsenor/MS\nsenora/S\nsenorita/S\nsens/DSG\nsensate/YNX\nsensately/I\nsensation/M\nsensational/Y\nsensationalism/MS\nsensationalist/S\nsensationalize/GSD\nsense/M\nsenseless/PY\nsenselessness/SM\nsensibility/ISM\nsensible/PRST\nsensibleness/MS\nsensibly/I\nsensitive/YIP\nsensitiveness's/I\nsensitiveness/MS\nsensitives\nsensitivity/ISM\nsensitization/CSM\nsensitize/SDCG\nsensitized/U\nsensitizers\nsensor/MS\nsensory\nsensual/YF\nsensualist/MS\nsensuality/MS\nsensuous/PY\nsensuousness/S\nsent/UFEA\nsentence/SDMG\nsentential/Y\nsententious/Y\nsentience/ISM\nsentient/YS\nsentiment/MS\nsentimental/Y\nsentimentalism/SM\nsentimentalist/SM\nsentimentality/SM\nsentimentalization/SM\nsentimentalize/RSDZG\nsentimentalizes/U\nsentinel/GDMS\nsentry/SM\nsepal/SM\nseparability/MSI\nseparable/PI\nseparableness/MI\nseparably/I\nseparate/YNGVDSXP\nseparateness/MS\nseparates/M\nseparation/M\nseparatism/SM\nseparatist/SM\nseparator/SM\nsepia/MS\nsepses\nsepsis/M\nsept/M\nsepta/M\nseptate/N\nseptennial/Y\nseptet/MS\nseptic/S\nsepticemia/SM\nsepticemic\nseptillion/M\nseptuagenarian/MS\nseptum/M\nsepulcher/MGSD\nsepulchers/UA\nsepulchral/Y\nseq\nsequel/MS\nsequence's/F\nsequence/DRSJZMG\nsequenced/A\nsequencer/M\nsequences/F\nsequent/F\nsequential/YF\nsequentiality/FM\nsequentialize/DSG\nsequester/SDG\nsequestrate/XGNDS\nsequestration/M\nsequin/SDMG\nsequitur\nsequoia/MS\nsera's\nseraglio/SM\nserape/S\nseraph/M\nseraphic\nseraphically\nseraphim's\nseraphs\nsere/TGDRS\nserenade/MGDRS\nserenader/M\nserendipitous/Y\nserendipity/MS\nserene/GTYRSDP\nsereneness/SM\nserenity/MS\nserf/MS\nserfdom/MS\nserge/DSGM\nsergeant/SM\nserial/MYS\nserialization/MS\nserialize/GSD\nseries/M\nserif/SMD\nserigraph/M\nserigraphs\nserious/PY\nseriousness/SM\nsermon/SGDM\nsermonize/GSD\nserological/Y\nserology/MS\nserons\nserous\nserpent/GSDM\nserpentine/GYS\nserrate/GNXSD\nserration/M\nserried\nserum/MS\nservant/SDMG\nserve/AGCFDSR\nserved/U\nserver/MCF\nservers\nservice's/E\nservice/MGSRD\nserviceability/SM\nserviceable/P\nserviceableness/M\nserviced/U\nserviceman/M\nservicemen\nservices/E\nservicewoman\nservicewomen\nserviette/MS\nservile/U\nservilely\nservileness/M\nserviles\nservility/SM\nserving/SM\nservitor/SM\nservitude/MS\nservo/S\nservomechanism/MS\nservomotor/MS\nsesame/MS\nsesquicentennial/S\nsessile\nsession/SM\nset's\nset/SIA\nsetback/S\nsetscrew/SM\nsett/BJGZSMR\nsettable/A\nsettee/MS\nsetter/M\nsetting's\nsetting/AS\nsettle/AUDSG\nsettlement/ASM\nsettler/MS\nsettling/S\nsetup/MS\nseven/SMH\nsevenfold\nsevenpence\nseventeen/HMS\nseventeenths\nsevenths\nseventieths\nseventy/MSH\nsever/SGTRD\nseveral/YS\nseveralfold\nseveralty/M\nseverance/SM\nsevere/PY\nsevered/E\nsevereness/SM\nsevering/E\nseverity/MS\nsevers/E\nsew/SAGD\nsewage/MS\nsewer/GSMD\nsewerage/SM\nsewing/SM\nsewn\nsex/GMDS\nsexagenarian/MS\nsexily\nsexiness/MS\nsexism/SM\nsexist/SM\nsexless\nsexologist/SM\nsexology/MS\nsexpot/SM\nsextant/SM\nsextet/SM\nsextillion/M\nsexton/MS\nsextuple/MDG\nsextuplet/MS\nsexual/Y\nsexuality/MS\nsexualized\nsexy/RTP\nsf\nsh/DRS\nshabbily\nshabbiness/SM\nshabby/RTP\nshack/GMDS\nshackle's\nshackle/UGDS\nshackler/M\nshad/DRJGSM\nshade/SM\nshaded/U\nshadeless\nshadily\nshadiness/MS\nshading/M\nshadow/GSDRM\nshadowbox/SDG\nshadower/M\nshadowiness/M\nshadowy/TRP\nshady/TRP\nshaft/SDMG\nshafting/M\nshag/MS\nshagged\nshagginess/SM\nshagging\nshaggy/TPR\nshah/M\nshahs\nshakable/U\nshakably/U\nshake/SRGZB\nshakeable\nshakedown/S\nshaken/U\nshakeout/SM\nshaker/M\nshakeup/S\nshakily\nshakiness/S\nshaking/M\nshaky/TPR\nshale/SM\nshall\nshallot/SM\nshallow/STPGDRY\nshallowness/SM\nshalom\nshalt\nsham/MDSG\nshaman/SM\nshamanic\nshamble/DSG\nshambles/M\nshame/SM\nshamefaced/Y\nshameful/YP\nshamefulness/S\nshameless/PY\nshamelessness/SM\nshammed\nshammer\nshamming\nshammy's\nshampoo/DRSMZG\nshampooer/M\nshamrock/SM\nshan't\nshandy/M\nshanghai/SDG\nshank/SMDG\nshantis\nshantung/MS\nshanty/SM\nshantytown/SM\nshape's\nshape/AGDSR\nshaped/U\nshapeless/PY\nshapelessness/SM\nshapeliness/S\nshapely/RPT\nshaper/S\nsharable/U\nshard/SM\nshare/DSRGZMB\nshareable\nsharecrop/S\nsharecropped\nsharecropper/MS\nsharecropping\nshared/U\nshareholder/MS\nshareholding/S\nsharer/M\nshareware/S\nsharia/SM\nshark/SGMD\nsharkskin/SM\nsharp/SGTZXPYRDN\nsharpen/ASGD\nsharpened/U\nsharpener/S\nsharper/M\nsharpie/SM\nsharpness/MS\nsharpshoot/JRGZ\nsharpshooter/M\nsharpshooting/M\nsharpy's\nshat\nshatter/DSG\nshattering/Y\nshatterproof\nshave/DSRJGZ\nshaved/U\nshaver/M\nshaving/M\nshaw/M\nshawl/SDMG\nshay/MS\nshe'd\nshe'll\nshe/M\nsheaf/MDGS\nshear/RDGZS\nshearer/M\nsheath/GJMDRS\nsheathe/UGSD\nsheather/M\nsheathing/M\nsheaths\nsheave/SDG\nsheaves/M\nshebang/MS\nshed's\nshed/U\nshedding\nsheds\nsheen/MDGS\nsheeny/TRSM\nsheep/M\nsheepdog/SM\nsheepfold/MS\nsheepherder/MS\nsheepish/YP\nsheepishness/SM\nsheepskin/SM\nsheer/PGTYRDS\nsheerness/S\nsheet/RDMJSG\nsheeting/M\nsheetlike\nsheik/SM\nsheikdom/SM\nsheikh's\nshekel/MS\nshelf/MDGS\nshell/RDMGS\nshellac/S\nshellacked\nshellacking/MS\nshelled/U\nshellfire/SM\nshellfish/SM\nshelter/DRMGS\nsheltered/U\nshelterer/M\nshelve/JRSDG\nshelver/M\nshelves/M\nshelving/M\nshenanigan/SM\nshepherd/DMSG\nshepherdess/S\nsherbet/MS\nsherd's\nsheriff/SM\nsherlock/M\nsherry/MS\nshew/GSD\nshewn\nshh\nshiatsu/S\nshibboleth/M\nshibboleths\nshield/MDRSG\nshielded/U\nshielder/M\nshift/RDGZS\nshiftily\nshiftiness/SM\nshiftless/PY\nshiftlessness/S\nshifty/TRP\nshill/DJSG\nshillelagh/M\nshillelaghs\nshilling/M\nshim/SM\nshimmed\nshimmer/DGS\nshimmery\nshimming\nshimmy/DSMG\nshin/SGZDRM\nshinbone/SM\nshindig/MS\nshine/S\nshiner/M\nshingle/MDRSG\nshingler/M\nshinguard\nshininess/MS\nshining/Y\nshinned\nshinning\nshinny/GDSM\nshinsplints\nshiny/PRT\nship's\nship/SLA\nshipboard/MS\nshipborne\nshipbuild/RGZJ\nshipbuilder/M\nshipload/SM\nshipman/M\nshipmate/SM\nshipmen\nshipment/AMS\nshipowner/MS\nshippable\nshipped/A\nshipper/SM\nshipping/MS\nshipshape\nshipwreck/GSMD\nshipwright/MS\nshipyard/MS\nshire/MS\nshirk/RDGZS\nshirker/M\nshirr/GJDS\nshirt/JDMSG\nshirtfront/S\nshirting/M\nshirtless\nshirtmake/R\nshirtmaker/M\nshirtsleeve/MS\nshirttail/S\nshirtwaist/SM\nshit/S!\nshitting/!\nshitty/RT!\nshiv/SZRM\nshiver/GDR\nshiverer/M\nshivery\nshivved\nshivving\nshlemiel's\nshoal/SRDMGT\nshoat/SM\nshock/SGZRD\nshocker/M\nshocking/Y\nshockproof\nshod/U\nshoddily\nshoddiness/SM\nshoddy/RSTP\nshoe/MS\nshoehorn/GSMD\nshoeing\nshoelace/MS\nshoemake/RZ\nshoemaker/M\nshoer's\nshoeshine/MS\nshoestring/MS\nshoetree/MS\nshogun/MS\nshogunate/SM\nshone\nshoo/DSG\nshoofly\nshook/SM\nshoot/SJRGZ\nshooter/M\nshootout/MS\nshop/MS\nshopkeep/RGZ\nshopkeeper/M\nshoplift/SRDGZ\nshoplifter/M\nshoplifting/M\nshoppe/RSDGZJ\nshopped/M\nshopper/M\nshopping/M\nshoptalk/SM\nshopworn\nshore/DSRGMJ\nshorebird/S\nshoreline/SM\nshoring/M\nshort/SGTXYRDNP\nshortage/MS\nshortbread/MS\nshortcake/SM\nshortchange/DSG\nshortcoming/MS\nshortcrust\nshortcut/MS\nshortcutting\nshorten/RDGJ\nshortener/M\nshortening/M\nshortfall/SM\nshorthand/DMS\nshorthorn/MS\nshortie's\nshortish\nshortlist/GD\nshortness/MS\nshortsighted/YP\nshortsightedness/S\nshortstop/MS\nshortwave/SM\nshorty/SM\nshot/MS\nshotgun/SM\nshotgunned\nshotgunner\nshotgunning\nshotted\nshotting\nshould/TZR\nshoulder/GMD\nshouldn't\nshout/SGZRDM\nshove/DSRG\nshovel/MDRSZG\nshoveler/M\nshovelful/MS\nshover/M\nshow/GDRZJS\nshowbiz\nshowbizzes\nshowboat/SGDM\nshowcase/MGSD\nshowdown/MS\nshower/GDM\nshowery/TR\nshowgirl/SM\nshowily\nshowiness/MS\nshowing/M\nshowman/M\nshowmanship/SM\nshowmen\nshown\nshowoff/S\nshowpiece/SM\nshowplace/SM\nshowroom/MS\nshowy/RTP\nshpt\nshrank\nshrapnel/SM\nshred/MS\nshredded\nshredder/MS\nshredding\nshrew/GSMD\nshrewd/RYTP\nshrewdness/SM\nshrewish/PY\nshrewishness/M\nshriek/SGDRMZ\nshrieker/M\nshrift/SM\nshrike/SM\nshrill/DRTGPS\nshrillness/MS\nshrilly\nshrimp/MDGS\nshrine/SDGM\nshrink/SRBG\nshrinkage/SM\nshrinker/M\nshrinking/U\nshrive/RSDG\nshrivel/GSD\nshriven\nshroud/GSMD\nshrub/SM\nshrubbed\nshrubbery/SM\nshrubbing\nshrubby/TR\nshrug/S\nshrugged\nshrugging\nshrunk/N\nshtick/S\nshuck/SGMRD\nshucker/M\nshucks/S\nshudder/DSG\nshuddery\nshuffle/GDSRZ\nshuffleboard/MS\nshuffled/A\nshuffles/A\nshuffling/A\nshun/S\nshunned\nshunning\nshunt/GSRD\nshunter/M\nshush/SDG\nshut/S\nshutdown/MS\nshuteye/SM\nshutoff/M\nshutout/SM\nshutter/DMGS\nshutterbug/S\nshuttering/M\nshutting\nshuttle/MGDS\nshuttlecock/MDSG\nshy/DRSGTZY\nshyer\nshyest\nshyness/SM\nshyster/SM\nsibilance/M\nsibilancy/M\nsibilant/SY\nsibling/SM\nsibyl/SM\nsibylline\nsic/S\nsick/GXTYNDRSP\nsickbay/M\nsickbed/S\nsicken/JRDG\nsickener/M\nsickening/Y\nsicker/Y\nsickie/SM\nsickish/PY\nsickle/SDGM\nsickliness/M\nsickly/TRSDPG\nsickness/MS\nsicko/S\nsickout/S\nsickroom/SM\nside/ISRM\nsidearm/S\nsideband/MS\nsidebar/MS\nsideboard/SM\nsideburns\nsidecar/MS\nsided/A\nsidedness\nsidekick/MS\nsidelight/SM\nsideline/MGDRS\nsidelong\nsideman/M\nsidemen\nsidepiece/S\nsider/FA\nsidereal\nsides/A\nsidesaddle/MS\nsideshow/MS\nsidesplitting\nsidestep/S\nsidestepped\nsidestepping\nsidestroke/GMSD\nsideswipe/GSDM\nsidetrack/SDG\nsidewalk/MS\nsidewall/MS\nsidewards\nsideway/SM\nsidewinder/SM\nsiding/SM\nsidle/DSG\nsiege/GMDS\nsienna/SM\nsierra/SM\nsiesta/MS\nsieve/GZMDS\nsift/GZJSDR\nsifted/UA\nsifter/M\nsigh/DRG\nsigher/M\nsighs\nsight/ISM\nsighted/P\nsighter/M\nsighting/S\nsightless/Y\nsightliness/UM\nsightly/TURP\nsightread\nsightsee/RZ\nsightseeing/S\nsigma/SM\nsigmoid\nsign's\nsign/GARDCS\nsignal's\nsignal/A\nsignaled\nsignaler/S\nsignaling\nsignalization/S\nsignalize/GSD\nsignally\nsignalman/M\nsignalmen\nsignals\nsignatory/SM\nsignature/MS\nsignboard/MS\nsigned/FU\nsigner/SC\nsignet/SGMD\nsignificance/IMS\nsignificant/YS\nsignificantly/I\nsignification/M\nsignify/DRSGNX\nsigning/S\nsignor/SFM\nsignora/SM\nsignore/M\nsignori\nsignories\nsignorina/SM\nsignorine\nsignpost/DMSG\nsigns/F\nsilage/GMSD\nsiled\nsilence/MZGRSD\nsilencer/M\nsilent/TSPRY\nsilentness/M\nsilhouette/GMSD\nsilica/SM\nsilicate/SM\nsiliceous\nsilicide/M\nsilicon/MS\nsilicone/SM\nsilicoses\nsilicosis/M\nsilk/GXNDMS\nsilken/DG\nsilkily\nsilkiness/SM\nsilkscreen/SM\nsilkworm/MS\nsilky/RSPT\nsill/MS\nsilliness/SM\nsilly/PRST\nsilo/GSM\nsilt/MDGS\nsiltation/M\nsiltstone/M\nsilty/RT\nsilver/RDYMGS\nsilverer/M\nsilverfish/MS\nsilversmith/M\nsilversmiths\nsilverware/SM\nsilvery/RTP\nsimian/S\nsimilar/EY\nsimilarity/EMS\nsimile/SM\nsimilitude/SME\nsimmer/GSD\nsimonize/SDG\nsimony/MS\nsimpatico\nsimper/GDS\nsimple/RSDGTP\nsimpleminded/YP\nsimpleness/S\nsimpleton/SM\nsimplex/S\nsimplicity/MS\nsimplified/U\nsimplify/ZXRSDNG\nsimplistic\nsimplistically\nsimply\nsimulacrum/M\nsimulate/XENGSD\nsimulation/ME\nsimulative\nsimulator/SEM\nsimulcast/GSD\nsimultaneity/SM\nsimultaneous/YP\nsimultaneousness/M\nsin/MAGS\nsince\nsincere/IY\nsincereness/M\nsincerer\nsincerest\nsincerity/MIS\nsine/SM\nsinecure/MS\nsinecurist/M\nsinew/SGMD\nsinewy\nsinful/YP\nsinfulness/SM\nsing/BGJZYDR\nsinge/S\nsingeing\nsinger/M\nsinging/Y\nsingle/PSDG\nsinglehanded/Y\nsingleness/SM\nsinglet/SM\nsingleton/SM\nsingletree/SM\nsingsong/GSMD\nsingular/SY\nsingularity/SM\nsingularization/M\nsinister/YP\nsinisterness/M\nsinistral/Y\nsink/GZSDRB\nsinkable/U\nsinker/M\nsinkhole/SM\nsinking/M\nsinless/YP\nsinlessness/M\nsinned\nsinner/MS\nsinning\nsinter/DM\nsinuosity/MS\nsinuous/PY\nsinuousities\nsinuousness/M\nsinus/MS\nsinusitis/SM\nsinusoid/MS\nsinusoidal/Y\nsip/S\nsiphon/DMSG\nsiphons/U\nsipped\nsipper/SM\nsipping\nsir/XGMNDS\nsire/MS\nsired/C\nsiren/M\nsires/C\nsiring/C\nsirloin/MS\nsirocco/MS\nsirred\nsirring\nsirup's\nsis/S\nsisal/MS\nsissified\nsissy/TRSM\nsister's/A\nsister/GDYMS\nsisterhood/MS\nsisterliness/MS\nsisterly/P\nsit/AG\nsitar/SM\nsitarist/SM\nsitcom/SM\nsite/DSJM\nsits\nsitter/MS\nsitting/SM\nsitu/S\nsituate/GNSDX\nsituation/M\nsituational/Y\nsituationist\nsitus/M\nsix/MRSH\nsixfold\nsixgun\nsixpence/MS\nsixpenny\nsixshooter\nsixteen/HRSM\nsixteenths\nsixth/Y\nsixths\nsixtieths\nsixty/SMH\nsizable/P\nsizableness/M\nsize/GJDRSBMZ\nsized/UA\nsizer/M\nsizes/A\nsizing/M\nsizzle/RSDG\nsizzler/M\nska/S\nskat/JMDRGZ\nskate/SM\nskateboard/SJGZMDR\nskater/M\nskedaddle/GSD\nskeet/RMS\nskein/MDGS\nskeletal/Y\nskeleton/MS\nskeptic/SM\nskeptical/Y\nskepticism/MS\nsketch/MRSDZG\nsketchbook/SM\nsketcher/M\nsketchily\nsketchiness/MS\nsketchpad\nsketchy/PRT\nskew/DRSPGZ\nskewer/GDM\nskewing/M\nskewness/M\nski/MNJSG\nskid/S\nskidded\nskidding\nskiff/GMDS\nskiing/M\nskilfully\nskill/DMSG\nskilled/U\nskillet/MS\nskillful/YUP\nskillfulness/MU\nskillfulnesses\nskilling/M\nskim/SM\nskimmed\nskimmer/MS\nskimming/SM\nskimp/GDS\nskimpily\nskimpiness/MS\nskimpy/PRT\nskin/SM\nskincare\nskindive/G\nskinflint/MS\nskinhead/SM\nskinless\nskinned\nskinner/SM\nskinniness/MS\nskinning\nskinny/TRSP\nskintight\nskip/S\nskipped\nskipper/SGDM\nskipping\nskirmish/RSDMZG\nskirmisher/M\nskirt/RDMGS\nskirter/M\nskirting/M\nskit/GSMD\nskitter/SDG\nskittish/YP\nskittishness/SM\nskittle/SM\nskivvy/GSDM\nskoal/SDG\nskulduggery/MS\nskulk/SRDGZ\nskulker/M\nskull/SDM\nskullcap/MS\nskullduggery's\nskunk/GMDS\nsky/MDRSGZ\nskycap/MS\nskydiver/SM\nskydiving/MS\nskyhook\nskyjack/ZSGRDJ\nskyjacker/M\nskylark/SRDMG\nskylarker/M\nskylight/MS\nskyline/MS\nskyrocket/GDMS\nskyscrape/RZ\nskyscraper/M\nskyward/S\nskywave\nskyway/M\nskywriter/MS\nskywriting/MS\nslab/MS\nslabbed\nslabbing\nslack/SPGTZXYRDN\nslacken/DG\nslacker/M\nslackness/MS\nslag/MS\nslagged\nslagging\nslain\nslake/DSG\nslaked/U\nslalom/SGMD\nslam/S\nslammed\nslammer/S\nslamming\nslander/MDRZSG\nslanderous/PY\nslanderousness/M\nslang/SMGD\nslangy/TR\nslant/SDG\nslanting/Y\nslantwise\nslap/MS\nslapdash/S\nslaphappy/TR\nslapped\nslapper\nslapping\nslapstick/MS\nslash/GZRSD\nslashing/Y\nslat/MDRSGZ\nslate/SM\nslater/M\nslather/SMDG\nslating/M\nslatted\nslattern/MYS\nslatting\nslaughter/SJMRDGZ\nslaughterer/M\nslaughterhouse/SM\nslave/DSRGZM\nslaveholder/SM\nslaver/GDM\nslavery/SM\nslavish/YP\nslavishness/SM\nslaw/MS\nslay/RGZS\nsleaze/S\nsleazily\nsleaziness/SM\nsleazy/RTP\nsled/SM\nsledded\nsledder/S\nsledding\nsledge/SDGM\nsledgehammer/MDGS\nsleek/PYRDGTS\nsleekness/S\nsleep/RMGZS\nsleeper/M\nsleepily\nsleepiness/SM\nsleeping/M\nsleepless/YP\nsleeplessness/SM\nsleepover/S\nsleepwalk/JGRDZS\nsleepwalker/M\nsleepwear/M\nsleepy/PTR\nsleepyhead/MS\nsleet/DMSG\nsleety/TR\nsleeve/SDGM\nsleeveless\nsleeving/M\nsleigh/GMD\nsleighs\nsleight/SM\nsleken/DG\nslender/RYTP\nslenderize/DSG\nslenderness/MS\nslept\nsleuth/GMD\nsleuths\nslew/DGS\nslice/DSRGZM\nsliced/U\nslicer/M\nslick/PSYRDGTZ\nslicker/M\nslickness/MS\nslid/GZDR\nslide/S\nslider/M\nslight/DRYPSTG\nslighter/M\nslighting/Y\nslightness/S\nslim/SPGYD\nslime/SM\nsliminess/S\nslimline\nslimmed\nslimmer/S\nslimmest\nslimming/S\nslimness/S\nslimy/PTR\nsling/GMRS\nslings/U\nslingshot/MS\nslink/GS\nslinky/RT\nslip/SM\nslipcase/MS\nslipcover/GMDS\nslipknot/SM\nslippage/SM\nslipped\nslipper/GSMD\nslipperiness/S\nslippery/PRT\nslipping\nslipshod\nslipstream/MDGS\nslipway/SM\nslit/SM\nslither/DSG\nslithery\nslitted\nslitter/S\nslitting\nsliver/GSDM\nslivery\nslob/MS\nslobber/SDG\nslobbery\nsloe/MS\nslog/S\nslogan/MS\nsloganeer/MG\nslogged\nslogging\nsloop/SM\nslop/DRSGZ\nslope/S\nsloped/U\nslopped\nsloppily\nsloppiness/SM\nslopping\nsloppy/RTP\nslosh/GSDM\nslot/MS\nsloth/GDM\nslothful/PY\nslothfulness/MS\nsloths\nslotted\nslotting\nslouch/DRSZG\nsloucher/M\nslouchy/RT\nslough/GMD\nsloughs\nsloven/YMS\nslovenliness/SM\nslovenly/TRP\nslow/PGTYDRS\nslowcoaches\nslowdown/MS\nslowish\nslowness/MS\nslowpoke/MS\nsludge/SDGM\nsludgy/TR\nslue/MGDS\nslug/MS\nsluggard/MS\nslugged\nslugger/SM\nslugging\nsluggish/YP\nsluggishness/SM\nsluice/SDGM\nslum/MS\nslumber/MDRGS\nslumberer/M\nslumberous\nslumlord/MS\nslummed\nslummer\nslumming\nslummy/TR\nslump/DSG\nslung/U\nslunk\nslur/MS\nslurp/GSD\nslurred\nslurried/M\nslurring\nslurry/MGDS\nslurrying/M\nslush/SDMG\nslushiness/SM\nslushy/RTP\nslut/MS\nsluttish\nslutty/TR\nsly/RTY\nslyness/MS\nsmack/SMRDGZ\nsmacker/M\nsmall/SGTRDP\nsmallholders\nsmallholding/MS\nsmallish\nsmallness/S\nsmallpox/SM\nsmalltalk\nsmalltime\nsmarmy/RT\nsmart/YRDNSGTXP\nsmarten/GD\nsmartness/S\nsmartypants\nsmash/GZRSD\nsmasher/M\nsmashing/Y\nsmashup/S\nsmattering/SM\nsmear/GRDS\nsmearer/M\nsmeary/TR\nsmell/SBRDG\nsmeller/M\nsmelliness/MS\nsmelly/TRP\nsmelt/SRDGZ\nsmelter/M\nsmidgen/MS\nsmilax/MS\nsmile/GMDSR\nsmiley/M\nsmilies\nsmiling/UY\nsmirch/SDG\nsmirk/GSMD\nsmite/GSR\nsmiter/M\nsmith/DMG\nsmithereens\nsmiths\nsmithy/SM\nsmitten\nsmock/SGMDJ\nsmocking/M\nsmog/SM\nsmoggy/TR\nsmoke/GZMDSRBJ\nsmokehouse/MS\nsmokeless\nsmoker/M\nsmokescreen/S\nsmokestack/MS\nsmokiness/S\nsmoking/M\nsmoky/RSPT\nsmolder/SGD\nsmoldering/Y\nsmooch/SDG\nsmooth/TZGPRDNY\nsmoothen/DG\nsmoother/M\nsmoothie/SM\nsmoothness/MS\nsmooths\nsmote\nsmother/GSD\nsmudge/GSD\nsmudginess/M\nsmudgy/TRP\nsmug/YSP\nsmugged\nsmugger\nsmuggest\nsmugging\nsmuggle/JZGSRD\nsmuggler/M\nsmugness/MS\nsmut/SM\nsmutted\nsmuttiness/SM\nsmutting\nsmutty/TRP\nsmrgsbord/SM\nsnack/SGMD\nsnaffle/GDSM\nsnafu/DMSG\nsnag/MS\nsnagged\nsnagging\nsnail/GSDM\nsnake/DSGM\nsnakebird/M\nsnakebite/MS\nsnakelike\nsnakeroot/M\nsnaky/TR\nsnap/US\nsnapback/M\nsnapdragon/MS\nsnapped/U\nsnapper/SM\nsnappily\nsnappiness/SM\nsnapping/U\nsnappish/PY\nsnappishness/SM\nsnappy/PTR\nsnapshot/MS\nsnapshotted\nsnapshotting\nsnare/DSRGM\nsnarer/M\nsnarf/JSGD\nsnarl/UGSD\nsnarler/M\nsnarling/Y\nsnarly/RT\nsnatch/DRSZG\nsnatcher/M\nsnazzily\nsnazzy/TR\nsneak/RDGZS\nsneaker/MD\nsneakily\nsneakiness/SM\nsneaking/Y\nsneaky/PRT\nsneer/GMRDJS\nsneerer/M\nsneering/Y\nsneeze/SRDG\nsnick/MRZ\nsnicker/GMRD\nsnide/YTSRP\nsnideness/M\nsniff/GZSRD\nsniffer/M\nsniffle/GDRS\nsniffler/M\nsniffles/M\nsnifter/MDSG\nsnigger's\nsnip/SGDRZ\nsnipe/SM\nsniper/M\nsnipped\nsnipper/SM\nsnippet/SM\nsnipping\nsnippy/RT\nsnit/SM\nsnitch/GDS\nsnivel/JSZGDR\nsniveler/M\nsnob/MS\nsnobbery/SM\nsnobbish/YP\nsnobbishness/S\nsnobby/RT\nsnood/SGDM\nsnook/SMRZ\nsnooker/GMD\nsnoop/SRDGZ\nsnooper/M\nsnoopy/RT\nsnoot/SDMG\nsnootily\nsnootiness/MS\nsnooty/TRP\nsnooze/GSD\nsnore/DSRGZ\nsnorkel/ZGSRDM\nsnort/GSZRD\nsnorter/M\nsnot/MS\nsnotted\nsnottily\nsnottiness/SM\nsnotting\nsnotty/TRP\nsnout/SGDM\nsnow/GDMS\nsnowball/SDMG\nsnowbank/SM\nsnowbird/SM\nsnowblower/S\nsnowboard/GZDRJS\nsnowbound\nsnowcapped\nsnowdrift/MS\nsnowdrop/MS\nsnowfall/MS\nsnowfield/MS\nsnowflake/MS\nsnowily\nsnowiness/MS\nsnowman/M\nsnowmen\nsnowmobile/GMDRS\nsnowplough/M\nsnowploughs\nsnowplow/SMGD\nsnowshed\nsnowshoe/MRS\nsnowshoeing\nsnowshoer/M\nsnowstorm/MS\nsnowsuit/S\nsnowy/RTP\nsnub/SP\nsnubbed\nsnubber\nsnubbing\nsnuff/GZSYRD\nsnuffbox/SM\nsnuffer/M\nsnuffle/GDSR\nsnuffler/M\nsnuffly/RT\nsnug/SYP\nsnugged\nsnugger\nsnuggest\nsnugging\nsnuggle/GDS\nsnuggly\nsnugness/MS\nso\nsoak/GDRSJ\nsoaker/M\nsoap/MDRGS\nsoapbox/DSMG\nsoapiness/S\nsoapstone/MS\nsoapsud/S\nsoapy/RPT\nsoar/DRJSG\nsoarer/M\nsoaring/Y\nsob/SZR\nsobbed\nsobbing/Y\nsober/PGTYRD\nsoberer/M\nsoberness/SM\nsobriety/SIM\nsobriquet/MS\nsoc/S\nsoccer/MS\nsociabilities\nsociability/IM\nsociable/S\nsociably/IU\nsocial/SY\nsocialism/SM\nsocialist/SM\nsocialistic\nsocialite/SM\nsociality/M\nsocialization/SM\nsocialize/RSDG\nsocialized/U\nsocializer/M\nsocially/U\nsocietal/Y\nsociety/MS\nsocio\nsociobiology/M\nsociocultural/Y\nsociodemographic\nsocioeconomic/S\nsocioeconomically\nsociolinguistics/M\nsociological/MY\nsociologist/SM\nsociology/SM\nsociometric\nsociometry/M\nsociopath/M\nsociopaths\nsock/GDMS\nsocket/SMDG\nsod/MS\nsoda/SM\nsodded\nsodden/DYPSG\nsoddenness/M\nsodding\nsodium/MS\nsodomite/MS\nsodomize/GDS\nsodomy/SM\nsoever\nsofa/SM\nsoft/SPXTYNR\nsoftball/MS\nsoftbound\nsoften/ZGRD\nsoftener/M\nsofthearted\nsoftie's\nsoftness/MS\nsoftware/MS\nsoftwood/SM\nsofty/SM\nsoggily\nsogginess/S\nsoggy/RPT\nsoign\nsoil/SGMD\nsoiled/U\nsoire/SM\nsojourn/RDZGSM\nsol/GSMDR\nsolace/GMSRD\nsolacer/M\nsolar/S\nsolaria\nsolarium/M\nsold/RU\nsolder/RDMSZG\nsoldier/MDYSG\nsoldiery/MS\nsole/YSP\nsolecism/MS\nsoled/FA\nsolemn/PTRY\nsolemness\nsolemnify/GSD\nsolemnity/MS\nsolemnization/SM\nsolemnize/GSD\nsolemnness/SM\nsolenoid/MS\nsoler/F\nsoles/IFA\nsolicit/SDG\nsolicitation/S\nsolicited/U\nsolicitor/MS\nsolicitous/YP\nsolicitousness/S\nsolicitude/MS\nsolid/STYRP\nsolidarity/MS\nsolidi\nsolidification/M\nsolidify/NXSDG\nsolidity/S\nsolidness/SM\nsolidus/M\nsoliloquies\nsoliloquize/DSG\nsoliloquy/M\nsoling/NM\nsolipsism/MS\nsolipsist/S\nsolitaire/SM\nsolitary/SP\nsolitude/SM\nsolo/DMSG\nsoloist/SM\nsolstice/SM\nsolubility/IMS\nsoluble/SI\nsolute's\nsolute/ENAXS\nsolution/AME\nsolvable/UI\nsolvating\nsolve/ABSRDZG\nsolved/EU\nsolvency/IMS\nsolvent's\nsolvent/IS\nsolvently\nsolver/MEA\nsolves/E\nsolving/E\nsoma/M\nsomatic\nsomber/PY\nsomberness/SM\nsombre\nsombrero/SM\nsome/Z\nsomebody'll\nsomebody/SM\nsomeday\nsomehow\nsomeone'll\nsomeone/SM\nsomeplace/M\nsomersault/DSGM\nsomerset/S\nsomersetted\nsomersetting\nsomething/S\nsometime/S\nsomeway/S\nsomewhat/S\nsomewhere/S\nsommelier/SM\nsomnambulism/SM\nsomnambulist/SM\nsomnolence/MS\nsomnolent/Y\nson/SMY\nsonar/SM\nsonata/MS\nsonatina/SM\nsong/MS\nsongbag\nsongbird/SM\nsongbook/S\nsongfest/MS\nsongful/YP\nsongfulness/M\nsongster/MS\nsongstress/SM\nsongwriter/SM\nsongwriting\nsonic/S\nsonnet/MDSG\nsonny/SM\nsonority/S\nsonorous/PY\nsonorousness/SM\nsonuvabitch\nsoon/TR\nsoonish\nsoot/MGDS\nsooth/GZTYSRDMJ\nsoothe\nsoother/M\nsoothing/YP\nsoothingness/M\nsooths\nsoothsay/JGZR\nsoothsayer/M\nsooty/RT\nsop/SM\nsophism/SM\nsophist/RMS\nsophister/M\nsophistic/S\nsophistical\nsophisticate/XNGDS\nsophisticated/U\nsophisticatedly\nsophistication/MU\nsophistry/SM\nsophomore/SM\nsophomoric\nsoporific/SM\nsoporifically\nsopped\nsopping/S\nsoppy/RT\nsoprano/SM\nsorbet/SM\nsorcerer/MS\nsorceress/S\nsorcery/MS\nsordid/PY\nsordidness/SM\nsore/PYTGDRS\nsorehead/SM\nsoreness/S\nsorghum/MS\nsorority/MS\nsorrel/SM\nsorrily\nsorriness/SM\nsorrow/GRDMS\nsorrower/M\nsorrowful/YP\nsorrowfulness/SM\nsorry/PTSR\nsort's\nsort/FSAGD\nsorta\nsortable\nsorted/U\nsorter/MS\nsortie/MSD\nsortieing\nsos\nsot/SM\nsottish\nsou'wester\nsou/SMH\nsoubriquet's\nsouffl/MS\nsough/DG\nsoughs\nsought/U\nsoul/MDS\nsoulful/YP\nsoulfulness/MS\nsoulless/Y\nsound's\nsound/AUD\nsoundboard/MS\nsounder's\nsounder/U\nsounders\nsoundest\nsounding's\nsounding/AY\nsoundings\nsoundless/Y\nsoundly/U\nsoundness/UMS\nsoundproof/GSD\nsoundproofing/M\nsounds/A\nsoundtrack/MS\nsoup/GMDS\nsoupy/RT\nsoupon/SM\nsour/TYDRPSG\nsource/ASDMG\nsourceless\nsourdough\nsourdoughs\nsourish\nsourness/MS\nsourpuss/MS\nsous/DSG\nsousaphone/SM\nsouse\nsouth/RDMG\nsouthbound\nsoutheast/RZMS\nsoutheaster/YM\nsoutheastern\nsoutheastward/S\nsouther/MY\nsoutherly/S\nsouthern/PZSYR\nsoutherner/M\nsouthernisms\nsouthernmost\nsouthing/M\nsouthland/M\nsouthpaw/MS\nsouths\nsouthward/S\nsouthwest/RMSZ\nsouthwester/YM\nsouthwestern\nsouthwestward/S\nsouvenir/SM\nsovereign/YMS\nsovereignty/MS\nsoviet/MS\nsow/ADGS\nsowbelly/M\nsowens/M\nsower/DS\nsown/A\nsox's\nsoy/MS\nsoybean/MS\nspa/MS\nspace/DSRGZMJ\nspacecraft/MS\nspaceflight/S\nspaceman/M\nspacemen\nspaceport/SM\nspacer/M\nspaceship/MS\nspacesuit/MS\nspacewalk/GSMD\nspacewoman\nspacewomen\nspacey\nspacial\nspacier\nspaciest\nspaciness\nspacing/M\nspacious/PY\nspaciousness/SM\nspade/DSRGM\nspadeful/SM\nspader/M\nspadework/SM\nspadices\nspadix/M\nspaghetti/SM\nspake\nspan/MS\nspandex/MS\nspandrels\nspangle/GMDS\nspaniel/SM\nspanielled\nspanielling\nspank/SRDJG\nspanker/M\nspanking/M\nspanned/U\nspanner/SM\nspanning\nspar/DRMGTS\nspare/PSY\nspareness/MS\nsparer/M\nspareribs\nsparing/UY\nspark/SGMRD\nsparker/M\nsparkle/DRSGZ\nsparkler/M\nsparky/RT\nsparling/SM\nsparred\nsparrer\nsparring/U\nsparrow/MS\nspars/TR\nsparse/YP\nsparseness/S\nsparsity/S\nspartan\nspasm/GSDM\nspasmodic\nspasmodically\nspastic/S\nspat/MS\nspate/SM\nspathe/MS\nspatial/Y\nspatiality/M\nspatted\nspatter/DGS\nspatterdock/M\nspatting\nspatula/SM\nspavin/DMS\nspawn/MRDSG\nspawner/M\nspay/DGS\nspeak/RBGZJS\nspeakable/U\nspeakeasy/SM\nspeaker/M\nspeakership/M\nspeaking/U\nspear/MRDGS\nspearer/M\nspearfish/SDMG\nspearhead/GSDM\nspearmint/MS\nspec'd\nspec'ing\nspec/SM\nspecial/SRYP\nspecialism/MS\nspecialist/MS\nspecialization/SM\nspecialize/GZDSR\nspecialized/U\nspecializing/U\nspecialty/MS\nspecie/MS\nspecif\nspecifiability\nspecifiable\nspecifiably\nspecific/SP\nspecifically\nspecification/SM\nspecificity/S\nspecified/U\nspecifier/SM\nspecifies\nspecify/AD\nspecifying\nspecimen/SM\nspecious/YP\nspeciousness/SM\nspeck/GMDS\nspeckle/GMDS\nspectacle/MSD\nspectacular/SY\nspectator/SM\nspecter's/A\nspecter/DMS\nspectra/M\nspectral/YP\nspectralness/M\nspectrogram/MS\nspectrograph/M\nspectrographically\nspectrography/M\nspectrometer/MS\nspectrometric\nspectrometry/M\nspectrophotometer/SM\nspectrophotometric\nspectrophotometry/M\nspectroscope/SM\nspectroscopic\nspectroscopically\nspectroscopy/SM\nspectrum/M\nspecular/Y\nspecularity\nspeculate/VNGSDX\nspeculation/M\nspeculative/Y\nspeculator/SM\nsped\nspeech/GMDS\nspeechless/YP\nspeechlessness/SM\nspeed/RMJGZS\nspeedboat/GSRM\nspeedboating/M\nspeeder/M\nspeedily\nspeediness/SM\nspeedometer/MS\nspeedster/SM\nspeedup/MS\nspeedway/SM\nspeedwell/MS\nspeedy/PTR\nspeer/M\nspeleological\nspeleologist/S\nspeleology/MS\nspell/RDSJGZ\nspellbind/SRGZ\nspellbinder/M\nspellbound\nspelldown/MS\nspelled/A\nspeller/M\nspelling/M\nspells/A\nspelunker/MS\nspelunking/S\nspend/SBJRGZ\nspender/M\nspendthrift/MS\nspent/U\nsperm/SM\nspermatophyte/M\nspermatozoa\nspermatozoon/M\nspermicidal\nspermicide/MS\nspew/DRGZJS\nspewer/M\nsphagnum/SM\nsphere/SDGM\nspheric/S\nspherical/Y\nspherics/M\nspheroid/SM\nspheroidal/Y\nspherule/MS\nsphincter/SM\nsphinx/MS\nspic/DGM\nspice/SM\nspicebush/M\nspicily\nspiciness/SM\nspicule/MS\nspicy/PTR\nspider/SM\nspiderweb/S\nspiderwort/M\nspidery/TR\nspiel/GDMS\nspier/M\nspiffy/TDRSG\nspigot/MS\nspike/GMDSR\nspiker/M\nspikiness/SM\nspiky/PTR\nspill/RDSG\nspillage/SM\nspillover/SM\nspillway/SM\nspin/S\nspinach/MS\nspinal/YS\nspindle/JGMDRS\nspindly/RT\nspine/MS\nspineless/YP\nspinelessness/M\nspinet/SM\nspininess/M\nspinnability/M\nspinnaker/SM\nspinner/SM\nspinneret/MS\nspinning/SM\nspinster/MS\nspinsterhood/SM\nspinsterish\nspiny/PRT\nspiracle/SM\nspiraea's\nspiral/YDSG\nspire's\nspire/AIDSGF\nspirea/MS\nspirit/GMDS\nspirited/PY\nspiritedness/M\nspiritless\nspirits/I\nspiritual/SYP\nspiritualism/SM\nspiritualist/SM\nspiritualistic\nspirituality/SM\nspirituous\nspirochete/SM\nspiry/TR\nspit/SGD\nspitball/SM\nspite's/A\nspite/CSDAG\nspiteful/PY\nspitefuller\nspitefullest\nspitefulness/MS\nspitfire/SM\nspitted\nspitting\nspittle/SM\nspittoon/SM\nsplash/GZDRS\nsplashdown/MS\nsplasher/M\nsplashily\nsplashiness/MS\nsplashy/RTP\nsplat/SM\nsplatted\nsplatter/DSG\nsplatting\nsplay/SDG\nsplayfeet\nsplayfoot/MD\nspleen/SM\nsplendid/YRPT\nsplendidness/M\nsplendor/SM\nsplendorous\nsplenetic/S\nsplice/RSDGZJ\nsplicer/M\nspline/MSD\nsplint/SGZMDR\nsplinter/GMD\nsplintery\nsplit/SM\nsplits/M\nsplittable\nsplitter/MS\nsplitting/S\nsplodge/SM\nsplotch/MSDG\nsplotchy/RT\nsplurge/GMDS\nsplutter/RDSG\nsplutterer/M\nspoil/CSZGDR\nspoilables\nspoilage/SM\nspoiled/U\nspoiler/MC\nspoilsport/SM\nspoke/DSG\nspoken/U\nspokeshave/MS\nspokesman/M\nspokesmen\nspokespeople\nspokesperson/S\nspokeswoman/M\nspokeswomen\nspoliation/MCS\nsponge/GMZRSD\nspongecake\nsponger/M\nsponginess/S\nspongy/TRP\nsponsor/DGMS\nsponsorship/S\nspontaneity/SM\nspontaneous/PY\nspontaneousness/M\nspoof/SMDG\nspook/SMDG\nspookiness/MS\nspooky/PRT\nspool/SRDMGZ\nspoon/GSMD\nspoonbill/SM\nspoonerism/SM\nspoonful/MS\nspoor/GSMD\nsporadic/Y\nsporadically\nspore/DSGM\nsporran/MS\nsport/VGSRDM\nsportiness/SM\nsporting/Y\nsportive/PY\nsportiveness/M\nsportscast/RSGZM\nsportsman/MY\nsportsmanlike/U\nsportsmanship/MS\nsportsmen\nsportswear/M\nsportswoman/M\nsportswomen\nsportswriter/S\nsporty/PRT\nspot/MSC\nspotless/YP\nspotlessness/MS\nspotlight/GDMS\nspotlit\nspotted/U\nspotter/MS\nspottily\nspottiness/SM\nspotting/M\nspotty/RTP\nspousal/MS\nspouse/GMSD\nspout/SGRD\nspouter/M\nsprain/SGD\nsprang/S\nsprat/SM\nsprawl/GSD\nspray/GZSRDM\nsprayed/UA\nsprayer/M\nsprays/A\nspread/RSJGZB\nspreadeagled\nspreader/M\nspreadsheet/S\nspree/MDS\nspreeing\nsprig/MS\nsprigged\nsprigging\nsprightliness/MS\nsprightly/PRT\nspring/SGZR\nspringboard/MS\nspringbok/MS\nspringeing\nspringer/M\nspringily\nspringiness/SM\nspringing/M\nspringlike\nspringtime/MS\nspringy/TRP\nsprinkle/DRSJZG\nsprinkler/DM\nsprinkling/M\nsprint/SGZMDR\nsprite/SM\nspritz/GZDSR\nsprocket/DMGS\nsprocketed/U\nsprout/GSD\nspruce/GMTYRSDP\nspruceness/SM\nsprue/M\nsprung/U\nspry/TRY\nspryness/S\nspud/MS\nspudded\nspudding\nspume/DSGM\nspumone's\nspumoni/S\nspumy/TR\nspun\nspunk/GSMD\nspunky/SRT\nspur/MS\nspurge/MS\nspurious/PY\nspuriousness/SM\nspurn/RDSG\nspurred\nspurring\nspurt/SGD\nsputa\nsputnik/MS\nsputter/DRGS\nsputum/M\nspy/DRSGM\nspyglass/MS\nsq\nsqq\nsqrt\nsquab/SM\nsquabbed\nsquabber\nsquabbest\nsquabbing\nsquabble/ZGDRS\nsquabbler/M\nsquad/SM\nsquadded\nsquadding\nsquadron/MDGS\nsqualid/PRYT\nsqualidness/SM\nsquall/GMRDS\nsqualler/M\nsqually/RT\nsqualor/SM\nsquamous/Y\nsquander/GSRD\nsquare/GMTYRSDP\nsquareness/SM\nsquarer/M\nsquarish\nsquash/GSRD\nsquashiness/M\nsquashy/RTP\nsquat/SPY\nsquatness/MS\nsquatted\nsquatter/SMDG\nsquattest\nsquatting\nsquaw/SM\nsquawk/GRDMZS\nsquawker/M\nsqueak/RDMGZS\nsqueaker/M\nsqueakily\nsqueakiness/S\nsqueaky/RPT\nsqueal/MRDSGZ\nsquealer/M\nsqueamish/YP\nsqueamishness/SM\nsqueegee/DSM\nsqueegeeing\nsqueeze/GZSRDB\nsqueezer/M\nsquelch/GDRS\nsquelcher/M\nsquelchy/RT\nsquib/SM\nsquibbed\nsquibbing\nsquid/SM\nsquidded\nsquidding\nsquiggle/MGDS\nsquiggly/RT\nsquint/GTSRD\nsquinter/M\nsquinting/Y\nsquire/SDGM\nsquirehood\nsquirm/SGD\nsquirmy/TR\nsquirrel/SGYDM\nsquirt/GSRD\nsquirter/M\nsquish/GSD\nsquishy/RTP\nssh\nst/GBJ\nstab/YS\nstabbed\nstabber/S\nstabbing/S\nstability/ISM\nstabilizability\nstabilization's\nstabilization/CS\nstabilize/CGSD\nstabilizer/MS\nstable's/F\nstable/RSDGMTP\nstableman/M\nstablemate\nstablemen\nstableness/UM\nstabler/U\nstables/F\nstablest/U\nstabling/M\nstably/U\nstaccato/S\nstack's\nstack/USDG\nstackable\nstacker/M\nstadia's\nstadias\nstadium/MS\nstaff's\nstaff/ADSG\nstaffer/MS\nstaffroom\nstag/DRMJSGZ\nstage/SM\nstagecoach/MS\nstagecraft/MS\nstagehand/MS\nstager/M\nstagestruck\nstagflation/SM\nstagged\nstagger/GSJDR\nstaggerer/M\nstaggering/Y\nstaggers/M\nstagging\nstaginess/M\nstaging/M\nstagnancy/SM\nstagnant/Y\nstagnate/NGDSX\nstagnation/M\nstagy/PTR\nstaid/YRTP\nstaidness/MS\nstain/SGRD\nstained/U\nstainer/M\nstainless/YS\nstair/MS\nstaircase/SM\nstairway/SM\nstairwell/MS\nstake/DSGM\nstakeholder/S\nstakeout/SM\nstalactite/SM\nstalag/M\nstalagmite/SM\nstale/PGYTDSR\nstalemate/SDMG\nstaleness/MS\nstalk/MRDSGZJ\nstalker/M\nstall/DMSJG\nstalled/I\nstallholders\nstallion/SM\nstalls/I\nstalwart/PYS\nstalwartness/M\nstamen/MS\nstamina/SM\nstaminate\nstammer/DRSZG\nstammerer/M\nstammering/Y\nstamp/RDSGZJ\nstamped/U\nstampede/MGDRS\nstampeder/M\nstamper/M\nstance/MIS\nstanch/GDRST\nstancher/M\nstanchion/SGMD\nstand/SJGZR\nstandalone\nstandard/YMS\nstandardization/AMS\nstandardize/GZDSR\nstandardized/U\nstandardizer/M\nstandardizes/A\nstandby\nstandbys\nstandee/MS\nstanding/M\nstandoff/SM\nstandoffish\nstandout/MS\nstandpipe/MS\nstandpoint/SM\nstandstill/SM\nstank/S\nstannic\nstannous\nstanza/MS\nstaph/M\nstaphs\nstaphylococcal\nstaphylococci\nstaphylococcus/M\nstaple/ZRSDGM\nstapled/U\nstapler/M\nstar/DRMGZS\nstarboard/SDMG\nstarch/MDSG\nstarchily\nstarchiness/MS\nstarchy/TRP\nstardom/MS\nstardust/MS\nstare/S\nstarfish/SM\nstargaze/ZGDRS\nstaring/U\nstark/SPGTYRD\nstarkness/MS\nstarless\nstarlet/MS\nstarlight/MS\nstarling/MS\nstarlit\nstarred\nstarring\nstarry/TR\nstarship\nstarstruck\nstart/ASGDR\nstarter/MS\nstartle/GDS\nstartling/PY\nstartup/SM\nstarvation/MS\nstarve/RSDG\nstarveling/M\nstarver/M\nstash/GSD\nstasis/M\nstat/DRSGV\nstate's/K\nstate/IGASD\nstatecraft/MS\nstated/U\nstatehood/MS\nstatehouse/S\nstateless/P\nstatelessness/MS\nstateliness/MS\nstately/PRT\nstatement/MSA\nstater/M\nstateroom/SM\nstates/K\nstateside\nstatesman/MY\nstatesmanlike\nstatesmanship/SM\nstatesmen\nstateswoman\nstateswomen\nstatewide\nstatic/S\nstatical/Y\nstatics/M\nstation/SZGMDR\nstationarity\nstationary/S\nstationer/M\nstationery/MS\nstationmaster/M\nstatistic/MS\nstatistical/Y\nstatistician/MS\nstator/SM\nstatuary/SM\nstatue/MSD\nstatuesque/YP\nstatuette/MS\nstature/MS\nstatus/SM\nstatute/SM\nstatutorily\nstatutory/P\nstaunch/PDRSYTG\nstaunchness/S\nstave/DGM\nstay/DRGZS\nstayer/M\nstd\nstdio\nstead/SGDM\nsteadfast/PY\nsteadfastness/MS\nsteadily/U\nsteadiness's\nsteadiness/US\nsteading/M\nsteady/DRSUTGP\nsteak/SM\nsteakhouse/SM\nsteal/SRHG\nstealer/M\nstealing/M\nstealth/M\nstealthily\nstealthiness/MS\nstealths\nstealthy/PTR\nsteam/SGZRDMJ\nsteamboat/MS\nsteamer/MDG\nsteamfitter/S\nsteamfitting/S\nsteamily\nsteaminess/SM\nsteamroll/GZRDS\nsteamroller/DMG\nsteamship/SM\nsteamy/RSTP\nsteed/SM\nsteel/SDMGZ\nsteeliness/SM\nsteelmaker/M\nsteelwork/ZSMR\nsteelworker/M\nsteely/TPRS\nsteelyard/MS\nsteep/SYRNDPGTX\nsteepen/GD\nsteeper/M\nsteeple/MS\nsteeplebush/M\nsteeplechase/GMSD\nsteeplejack/MS\nsteepness/S\nsteer/SGBRDJ\nsteerage/MS\nsteerer/M\nsteersman/M\nsteersmen\nsteeves\nstegosauri\nstegosaurus/S\nstein/SGZMRD\nstellar\nstellated\nstem/MS\nstemless\nstemmed/U\nstemming\nstemware/MS\nstench/GMDS\nstencil/GDRMSZ\nstenciler/M\nstencillings\nsteno/SM\nstenographer/SM\nstenographic\nstenography/SM\nstenotype/M\nstentorian\nstep/MIS\nstepbrother/MS\nstepchild/M\nstepchildren\nstepdaughter/MS\nstepfather/SM\nstepladder/SM\nstepmother/SM\nstepparent/SM\nsteppe/RSDGMZ\nstepper/M\nsteppingstone/S\nstepsister/SM\nstepson/SM\nstepwise\nstereo/GSDM\nstereographic\nstereography/M\nstereophonic\nstereoscope/MS\nstereoscopic\nstereoscopically\nstereoscopy/M\nstereotype/GMZDRS\nstereotypic\nstereotypical/Y\nsterile\nsterility/SM\nsterilization/SM\nsterilize/RSDGZ\nsterilized/U\nsterilizes/A\nsterling/MPYS\nsterlingness/M\nstern/SYRDPGT\nsternal\nsternness/S\nsternum/SM\nsteroid/MS\nsteroidal\nstertorous\nstet/MS\nstethoscope/SM\nstetson/MS\nstetted\nstetting\nstevedore/GMSD\nstew/GDMS\nsteward/DMSG\nstewardess/SM\nstewardship/MS\nstick/MRDSGZ\nsticker/M\nstickily\nstickiness/SM\nstickle/GZDR\nstickleback/MS\nstickler/M\nstickpin/SM\nstickup/SM\nsticky/GPTDRS\nstiff/GTXPSYRND\nstiffen/JZRDG\nstiffness/MS\nstifle/GJRSD\nstifler/M\nstifling/Y\nstigma/MS\nstigmata\nstigmatic/S\nstigmatization's\nstigmatization/C\nstigmatizations\nstigmatize/DSG\nstigmatized/U\nstile/GMDS\nstiletto/MDSG\nstill/RDIGS\nstillbirth/M\nstillbirths\nstillborn/S\nstiller/MI\nstillest\nstillness/MS\nstilt/GDMS\nstilted/PY\nstimulant/MS\nstimulate/SDVGNX\nstimulated/U\nstimulation/M\nstimulative/S\nstimulator/M\nstimulatory\nstimuli/M\nstimulus/MS\nsting/GZR\nstinger/M\nstingily\nstinginess/MS\nstinging/Y\nstingray/MS\nstingy/RTP\nstink/GZRJS\nstinkbug/S\nstinker/M\nstinking/Y\nstinkpot/M\nstinky/RT\nstint/JGRDMS\nstinter/M\nstinting/U\nstipend/MS\nstipendiary\nstipple/JDRSG\nstippler/M\nstipulate/XNGSD\nstipulation/M\nstir/S\nstirred/U\nstirrer/SM\nstirring/YS\nstirrup/SM\nstitch's\nstitch/ASDG\nstitcher/M\nstitchery/S\nstitching/MS\nstoat/SM\nstochastic\nstochastically\nstochasticity\nstock's\nstock/SGAD\nstockade/SDMG\nstockbreeder/SM\nstockbroker/MS\nstockbroking/S\nstocker/SM\nstockholder/SM\nstockily\nstockiness/SM\nstockinet's\nstockinette/S\nstocking/MDS\nstockist/MS\nstockpile/GRSD\nstockpiler/M\nstockpot/MS\nstockroom/MS\nstocktaking/MS\nstocky/PRT\nstockyard/SM\nstodge/M\nstodgily\nstodginess/S\nstodgy/TRP\nstogy/SM\nstoic/MS\nstoical/Y\nstoichiometric\nstoichiometry/M\nstoicism/SM\nstoke/DSRGZ\nstoker/M\nstokes/M\nstole/MDS\nstolen\nstolid/PTYR\nstolidity/S\nstolidness/S\nstolon/SM\nstomach/RSDMZG\nstomachache/MS\nstomacher/M\nstomachs\nstomp/DSG\nstone/DSRGM\nstonecutter/SM\nstoneless\nstonemason/MS\nstoner/M\nstonewall/GDS\nstoneware/MS\nstonewashed\nstonework/SM\nstonewort/M\nstonily\nstoniness/MS\nstony/TPR\nstood\nstooge/SDGM\nstool/SDMG\nstoop/SDG\nstop's\nstop/US\nstopcock/MS\nstopgap/SM\nstoplight/SM\nstopover/MS\nstoppable/U\nstoppage/MS\nstopped/U\nstopper/GMDS\nstopping/M\nstopple/GDSM\nstops/M\nstopwatch/SM\nstorage/SM\nstore's\nstore/ADSRG\nstorefront/SM\nstorehouse/MS\nstorekeep/ZR\nstorekeeper/M\nstoreroom/SM\nstork/SM\nstorm/SRDMGZ\nstormbound\nstormer/M\nstormily\nstorminess/S\nstormtroopers\nstormy/PTR\nstory/GSDM\nstoryboard/MDSG\nstorybook/MS\nstoryline\nstoryteller/SM\nstorytelling/MS\nstoup/SM\nstout/STYRNP\nstouten/DG\nstouthearted\nstoutness/MS\nstove/DSRGM\nstovepipe/SM\nstover/M\nstow/GDS\nstowage/SM\nstowaway/MS\nstraddle/ZDRSG\nstraddler/M\nstrafe/GRSD\nstrafer/M\nstraggle/GDRSZ\nstraggly/RT\nstraight/RNDYSTXGP\nstraightaway/S\nstraightedge/MS\nstraighten/ZGDR\nstraightener/M\nstraightforward/SYP\nstraightforwardness/MS\nstraightjacket's\nstraightness/MS\nstraightway/S\nstrain/ASGZDR\nstrained/UF\nstrainer/MA\nstraining/F\nstrains/F\nstrait/XTPSMGYDNR\nstraiten/DG\nstraitjacket/GDMS\nstraitlaced\nstraitness/M\nstrand/SDRG\nstranded/P\nstrange/PYZTR\nstrangeness/SM\nstranger/GMD\nstrangle/JDRSZG\nstranglehold/MS\nstrangles/M\nstrangulate/NGSDX\nstrangulation/M\nstrap's\nstrap/US\nstrapless/S\nstrapped/U\nstrapping/S\nstrata/MS\nstratagem/SM\nstrategic/S\nstrategical/Y\nstrategics/M\nstrategist/SM\nstrategy/SM\nstrati\nstratification/M\nstratified/U\nstratify/NSDGX\nstratigraphic\nstratigraphical\nstratigraphy/M\nstratosphere/SM\nstratospheric\nstratospherically\nstratum/M\nstratus/M\nstraw/SMDG\nstrawberry/SM\nstrawflower/SM\nstray/GSRDM\nstrayer/M\nstreak/DRMSGZ\nstreaker/M\nstreaky/TR\nstream/GZSMDR\nstreamed/U\nstreamer/M\nstreaming/M\nstreamline/SRDGM\nstreet/SMZ\nstreetcar/MS\nstreetlight/SM\nstreetwalker/MS\nstreetwise\nstrength/NMX\nstrengthen/AGDS\nstrengthener/MS\nstrengths\nstrenuous/PY\nstrenuousness/SM\nstrep/MS\nstreptococcal\nstreptococci\nstreptococcus/M\nstreptomycin/SM\nstress/DSMG\nstressed/U\nstressful/YP\nstretch/BDRSZG\nstretchability/M\nstretchable/U\nstretcher/DMG\nstretchy/TRP\nstrew/GDHS\nstrewn\nstria/M\nstriae\nstriate/DSXGN\nstriated/U\nstriation/M\nstricken\nstrict/AF\nstricter\nstrictest\nstrictly\nstrictness/S\nstricture/SM\nstridden\nstride/RSGM\nstridency/S\nstrident/Y\nstrider/M\nstrife/SM\nstrike/RSGZJ\nstrikebreak/ZGR\nstrikebreaker/M\nstrikebreaking/M\nstrikeout/S\nstriker/M\nstriking/Y\nstring's\nstring/SAG\nstringed\nstringency/S\nstringent/Y\nstringer/MS\nstringiness/SM\nstringing/M\nstringy/RTP\nstrip/GRDMS\nstripe/SM\nstriper/M\nstripling/M\nstripped/U\nstripper/MS\nstripping\nstriptease/SRDGZM\nstripteaser/M\nstripy/RT\nstrive/JRSG\nstriven\nstriver/M\nstrobe/SDGM\nstroboscope/SM\nstroboscopic\nstrode\nstroke/ZRSDGM\nstroking/M\nstroll/GZSDR\nstroller/M\nstrong/YRT\nstrongbow\nstrongbox/MS\nstronghold/SM\nstrongish\nstrongman/M\nstrongmen\nstrongroom/MS\nstrontium/SM\nstrop/SM\nstrophe/MS\nstrophic\nstropped\nstropping\nstrove\nstruck\nstructural/Y\nstructuralism/M\nstructuralist/SM\nstructure/SRDMG\nstructured/AU\nstructureless\nstructures/A\nstructuring/A\nstrudel/MS\nstruggle/GDRS\nstruggler/M\nstrum/S\nstrummed\nstrumming\nstrumpet/GSDM\nstrung/UA\nstrut/S\nstrutted\nstrutter/M\nstrutting\nstrychnine/MS\nstub/MS\nstubbed/M\nstubbing\nstubble/SM\nstubbly/RT\nstubborn/SGTYRDP\nstubbornness/SM\nstubby/SRT\nstucco/GDM\nstuccoes\nstuck/U\nstud/MS\nstudbook/SM\nstudded\nstudding/SM\nstudent/SM\nstudentship/MS\nstudied/PY\nstudiedness/M\nstudier/SM\nstudio/MS\nstudious/PY\nstudiousness/SM\nstudy/AGDS\nstuff/JGSRD\nstuffily\nstuffiness/SM\nstuffing/M\nstuffy/TRP\nstultify/NXGSD\nstumble/GZDSR\nstumbling/Y\nstump/RDMSG\nstumpage/M\nstumper/M\nstumpy/RT\nstun/S\nstung\nstunk\nstunned\nstunner/M\nstunning/Y\nstunt/GSDM\nstunted/P\nstupefaction/SM\nstupefy/DSG\nstupendous/PY\nstupendousness/M\nstupid/PTYRS\nstupidity/SM\nstupidness/M\nstupor/MS\nsturdily\nsturdiness/SM\nsturdy/SRPT\nsturgeon/SM\nstutter/DRSZG\nsty/DSGM\nstyle/GZMDSR\nstyled/A\nstyles/A\nstyli\nstyling/A\nstylish/PY\nstylishness/S\nstylist/MS\nstylistic/S\nstylistically\nstylites\nstylization/MS\nstylize/DSG\nstylos\nstylus/SM\nstymie/SD\nstymieing\nstymy's\nstyptic/S\nstyrene/MS\nsuable\nsuasion/EMS\nsuave/PRYT\nsuaveness/S\nsuavity/SM\nsub/MS\nsubaltern/SM\nsubarctic/S\nsubareas\nsubassembly/M\nsubatomic/S\nsubbasement/SM\nsubbed\nsubbing\nsubbranch/S\nsubcaste/M\nsubcategorizing\nsubcategory/SM\nsubchain\nsubclass/MS\nsubclassifications\nsubclauses\nsubcommand/S\nsubcommittee/SM\nsubcompact/S\nsubcomponent/MS\nsubcomputation/MS\nsubconcept\nsubconscious/PSY\nsubconsciousness/SM\nsubconstituent\nsubcontinent/MS\nsubcontinental\nsubcontract/SMDG\nsubcontractor/SM\nsubcultural\nsubculture/GMDS\nsubcutaneous/Y\nsubdirectory/S\nsubdistrict/M\nsubdivide/SRDG\nsubdivision/SM\nsubdue/GRSD\nsubdued/Y\nsubduer/M\nsubexpression/MS\nsubfamily/SM\nsubfield/MS\nsubfile/SM\nsubfreezing\nsubgoal/SM\nsubgraph\nsubgraphs\nsubgroup/SGM\nsubharmonic/S\nsubhead/MGJS\nsubheading/M\nsubhuman/S\nsubindex/M\nsubinterval/MS\nsubj\nsubject/GVDMS\nsubjection/SM\nsubjective/PSY\nsubjectiveness/M\nsubjectivist/S\nsubjectivity/SM\nsubjoin/DSG\nsubjugate/NGXSD\nsubjugation/M\nsubjunctive/S\nsublayer\nsublease/DSMG\nsublet/S\nsubletting\nsublimate/GNSDX\nsublimation/M\nsublime/GRSDTYP\nsublimeness/M\nsublimer/M\nsubliminal/Y\nsublimity/SM\nsublist/SM\nsubliterary\nsublunary\nsubmachine\nsubmarginal\nsubmarine/MZGSRD\nsubmariner/M\nsubmerge/DSG\nsubmergence/SM\nsubmerse/XNGDS\nsubmersible/S\nsubmersion/M\nsubmicroscopic\nsubmission/SAM\nsubmissive/PY\nsubmissiveness/MS\nsubmit/SA\nsubmittable\nsubmittal\nsubmitted/A\nsubmitter/S\nsubmitting/A\nsubmode/S\nsubmodule/MS\nsubnational\nsubnet/SM\nsubnetwork/SM\nsubnormal/SY\nsuboptimal\nsuborbital\nsuborder/MS\nsubordinate/YVNGXPSD\nsubordinately/I\nsubordinates/I\nsubordination/IMS\nsubordinator\nsuborn/GSD\nsubornation/SM\nsubpage\nsubparagraph/M\nsubpart/MS\nsubplot/MS\nsubpoena/GSDM\nsubpopulation/MS\nsubproblem/SM\nsubprocess/SM\nsubprofessional/S\nsubprogram/SM\nsubproject\nsubproof/SM\nsubquestion/MS\nsubrange/SM\nsubregion/MS\nsubregional/Y\nsubrogation/M\nsubroutine/SM\nsubsample/MS\nsubschema/MS\nsubscribe/ASDG\nsubscriber/SM\nsubscript/SGD\nsubscripted/U\nsubscription/MS\nsubsection/SM\nsubsegment/SM\nsubsentence\nsubsequence/MS\nsubsequent/SYP\nsubservience/SM\nsubservient/SY\nsubset/MS\nsubside/SDG\nsubsidence/MS\nsubsidiarity\nsubsidiary/MS\nsubsidization/MS\nsubsidize/ZRSDG\nsubsidized/U\nsubsidizer/M\nsubsidy/MS\nsubsist/SGD\nsubsistence/MS\nsubsistent\nsubsocietal\nsubsoil/DRMSG\nsubsonic\nsubspace/MS\nsubspecies/M\nsubstance/MS\nsubstandard\nsubstantial/PYS\nsubstantially/IU\nsubstantialness/M\nsubstantiate/VGNSDX\nsubstantiated/U\nsubstantiation/MFS\nsubstantive/PSYM\nsubstantiveness/M\nsubstantivity\nsubstation/MS\nsubsterilization\nsubstitutability\nsubstitute/NGVBXDRS\nsubstituted/U\nsubstitution/M\nsubstitutionary\nsubstitutive/Y\nsubstrata\nsubstrate/MS\nsubstratum/M\nsubstring/S\nsubstructure/SM\nsubsume/SDG\nsubsurface/S\nsubsystem/MS\nsubtable/S\nsubtask/SM\nsubteen/SM\nsubtenancy/MS\nsubtenant/SM\nsubtend/DS\nsubterfuge/SM\nsubterranean/SY\nsubtest\nsubtext/SM\nsubtitle/DSMG\nsubtle/RPT\nsubtleness/M\nsubtlety/MS\nsubtly/U\nsubtopic/SM\nsubtotal/GSDM\nsubtract/SRDZVG\nsubtracter/M\nsubtraction/MS\nsubtrahend/SM\nsubtree/SM\nsubtropic/S\nsubtropical\nsubtype/MS\nsubunit/SM\nsuburb/MS\nsuburban/S\nsuburbanite/MS\nsuburbanization/MS\nsuburbanized\nsuburbanizing\nsuburbia/SM\nsubvention/MS\nsubversion/SM\nsubversive/SPY\nsubversiveness/MS\nsubvert/SGDR\nsubverter/M\nsubway/MDGS\nsubzero\nsucceed/GDRS\nsucceeder/M\nsuccess/MSV\nsuccessful/UY\nsuccessfulness/M\nsuccession/SM\nsuccessive/YP\nsuccessiveness/M\nsuccessor/MS\nsuccessorship\nsuccinct/RYPT\nsuccinctness/SM\nsuccor/SGZRDM\nsuccored/U\nsuccorer/M\nsuccotash/SM\nsuccubus/M\nsucculence/SM\nsucculency/MS\nsucculent/S\nsuccumb/SDG\nsuch\nsuchlike\nsuck/GZSDRB\nsucker/DMG\nsuckle/SDJG\nsuckling/M\nsucrose/MS\nsuction/SMGD\nsud/S\nsudden/YPS\nsuddenness/SM\nsuds/DSRG\nsudsy/TR\nsue/ZGDRS\nsued/DG\nsuede/SM\nsuer/M\nsuet/MS\nsuety\nsuffer/SJRDGZ\nsufferance/SM\nsufferer/M\nsuffering/M\nsuffice/GRSD\nsufficiency/SIM\nsufficient/IY\nsuffix/GMRSD\nsuffixation/S\nsuffixed/U\nsuffocate/XSDVGN\nsuffocating/Y\nsuffragan/S\nsuffrage/MS\nsuffragette/MS\nsuffragist/SM\nsuffuse/VNGSDX\nsuffusion/M\nsugar/SJGMD\nsugarcane/S\nsugarcoat/GDS\nsugarless\nsugarplum/MS\nsugary/TR\nsuggest/DRZGVS\nsuggester/M\nsuggestibility/SM\nsuggestible\nsuggestion/MS\nsuggestive/PY\nsuggestiveness/MS\nsugillate\nsuicidal/Y\nsuicide/GSDM\nsuit/MDGZBJS\nsuitability/SU\nsuitable/P\nsuitableness/S\nsuitably/U\nsuitcase/MS\nsuite/SM\nsuited/U\nsuiting/M\nsuitor/SM\nsukiyaki/SM\nsulfa/S\nsulfaquinoxaline\nsulfate/MSDG\nsulfide/S\nsulfite/M\nsulfonamide/SM\nsulfur/DMSG\nsulfuric\nsulfurous/YP\nsulfurousness/M\nsulk/GDS\nsulkily\nsulkiness/S\nsulky/RSPT\nsullen/TYRP\nsullenness/MS\nsullied/U\nsully/GSD\nsulphate/SM\nsulphide/MS\nsulphuric\nsultan/SM\nsultana/SM\nsultanate/MS\nsultrily\nsultriness/SM\nsultry/PRT\nsum/MRS\nsumac/SM\nsumach's\nsumer/F\nsummability/M\nsummable\nsummand/MS\nsummarily\nsummarization/MS\nsummarize/GSRDZ\nsummarized/U\nsummarizer/M\nsummary/MS\nsummation/FMS\nsummed\nsummer/SGDM\nsummerhouse/MS\nsummertime/MS\nsummery/TR\nsumming\nsummit/GMDS\nsummitry/MS\nsummon/JSRDGZ\nsummoner/M\nsummons/MSDG\nsumo/SM\nsump/SM\nsumptuous/PY\nsumptuousness/SM\nsun/MS\nsunbaked\nsunbath/ZRSDG\nsunbathe\nsunbather/M\nsunbathing/M\nsunbaths\nsunbeam/MS\nsunblock/S\nsunbonnet/MS\nsunburn/GSMD\nsunburst/MS\nsuncream\nsundae/MS\nsunder/SDG\nsundial/MS\nsundown/MRDSZG\nsundowner/M\nsundris\nsundry/S\nsunfish/SM\nsunflower/MS\nsung/U\nsunglass/MS\nsunk/SN\nsunlamp/S\nsunless\nsunlight/MS\nsunlit\nsunned\nsunniness/SM\nsunning\nsunny/RSTP\nsunrise/GMS\nsunroof/S\nsunscreen/S\nsunset/MS\nsunsetting\nsunshade/MS\nsunshine/MS\nsunshiny\nsunspot/SM\nsunstroke/MS\nsuntan/SM\nsuntanned\nsuntanning\nsunup/MS\nsup/RSZ\nsuper/DG\nsuperabundance/MS\nsuperabundant\nsuperannuate/GNXSD\nsuperannuation/M\nsuperb/YRPT\nsuperbness/M\nsupercargo/M\nsupercargoes\nsupercharge/SRDZG\nsupercharger/M\nsupercilious/PY\nsuperciliousness/SM\nsupercity/S\nsuperclass/M\nsupercomputer/MS\nsupercomputing\nsuperconcept\nsuperconducting\nsuperconductivity/SM\nsuperconductor/SM\nsupercooled\nsupercooling\nsupercritical\nsuperdense\nsuperego/SM\nsupererogation/MS\nsupererogatory\nsuperficial/SPY\nsuperficiality/S\nsuperfine\nsuperfix/M\nsuperfluity/MS\nsuperfluous/YP\nsuperfluousness/S\nsuperheat/D\nsuperhero/SM\nsuperheroes\nsuperhighway/MS\nsuperhuman/YP\nsuperhumanness/M\nsuperimpose/SDG\nsuperimposition/MS\nsuperintend/GSD\nsuperintendence/S\nsuperintendency/SM\nsuperintendent/SM\nsuperior/SMY\nsuperiority/MS\nsuperlative/PYS\nsuperlativeness/M\nsuperlunary\nsupermachine\nsuperman/M\nsupermarket/SM\nsupermen\nsupermodel\nsupermom/S\nsupernal\nsupernatant\nsupernatural/SPY\nsupernaturalism/M\nsupernaturalness/M\nsupernormal/Y\nsupernova/MS\nsupernovae\nsupernumerary/S\nsuperordinate\nsuperpose/BSDG\nsuperposition/MS\nsuperpower/MS\nsuperpredicate\nsupersaturate/XNGDS\nsupersaturation/M\nsuperscribe/GSD\nsuperscript/DGS\nsuperscription/SM\nsupersede/SRDG\nsuperseder/M\nsupersensitive/P\nsupersensitiveness/M\nsuperset/MS\nsupersonic/S\nsupersonically\nsupersonics/M\nsuperstar/SM\nsuperstition/SM\nsuperstitious/YP\nsuperstore/S\nsuperstructural\nsuperstructure/SM\nsupertanker/SM\nsupertitle/MSDG\nsuperuser/MS\nsupervene/GSD\nsupervention/S\nsupervise/SDGNX\nsupervised/U\nsupervision/M\nsupervisor/SM\nsupervisory\nsuperwoman/M\nsuperwomen\nsupine/PSY\nsupineness/M\nsupp/YDRGZ\nsupper/DMG\nsuppl/RDGT\nsupplant/SGRD\nsupplanter/M\nsupple/SPLY\nsupplement/SMDRG\nsupplemental/S\nsupplementary/S\nsupplementation/S\nsupplementer/M\nsuppleness/SM\nsuppliant/S\nsupplicant/MS\nsupplicate/NGXSD\nsupplication/M\nsupplier/AM\nsupply/MAZGSRD\nsupport/ZGVSBDR\nsupportability/M\nsupportable/UI\nsupported/U\nsupporter/M\nsupporting/Y\nsupportive/Y\nsuppose/SRDBJG\nsupposed/Y\nsupposition/MS\nsuppository/MS\nsuppress/VGSD\nsuppressant/S\nsuppressed/U\nsuppressible/I\nsuppression/SM\nsuppressive/P\nsuppressor/S\nsuppurate/NGXSD\nsuppuration/M\nsupra\nsupranational\nsupranationalism/M\nsuprasegmental\nsupremacist/SM\nsupremacy/SM\nsupremal\nsupreme/PSRTY\nsupremeness/M\nsupremo/M\nsupt\nsurcease/DSMG\nsurcharge/MGSD\nsurcingle/MGSD\nsurd/M\nsure/PU\nsured/I\nsurefire\nsurefooted\nsurely\nsureness's/U\nsureness/MS\nsurer/I\nsurest\nsurety/SM\nsurf/SJDRGMZ\nsurface/GSRDPZM\nsurfaced/UA\nsurfacer/AMS\nsurfaces/A\nsurfacing/A\nsurfactant/SM\nsurfboard/MDSG\nsurfeit/SDRMG\nsurfer/M\nsurfing/M\nsurge/GYMDS\nsurged/A\nsurgeon/MS\nsurgery/MS\nsurges/A\nsurgical/Y\nsurliness/SM\nsurly/TPR\nsurmise/SRDG\nsurmiser/M\nsurmount/DBSG\nsurmountable/IU\nsurname/GSDM\nsurpass/GDS\nsurpassed/U\nsurpassing/Y\nsurplice/SM\nsurplus/MS\nsurplussed\nsurplussing\nsurprise/MGDRSJ\nsurprised/U\nsurpriser/M\nsurprising/YU\nsurreal/S\nsurrealism/MS\nsurrealist/S\nsurrealistic\nsurrealistically\nsurreality\nsurrender/DRSG\nsurrenderer/M\nsurreptitious/PY\nsurreptitiousness/S\nsurrey/SM\nsurrogacy/S\nsurrogate/SDMNG\nsurrogation/M\nsurround/JGSD\nsurrounding/M\nsurtax/SDGM\nsurveillance/SM\nsurveillant\nsurvey/JDSG\nsurveyed/A\nsurveying/M\nsurveyor/MS\nsurveys/A\nsurvivability/M\nsurvivable/U\nsurvival/MS\nsurvivalist/S\nsurvive/SRDBG\nsurvivor/MS\nsurvivorship/M\nsusceptibilities\nsusceptibility/IM\nsusceptible/I\nsushi/SM\nsuspect/GSDR\nsuspected/U\nsuspecter/M\nsuspecting/U\nsuspend/DRZGS\nsuspended/UA\nsuspender/M\nsuspense/MXNVS\nsuspenseful\nsuspension/AM\nsuspensive/Y\nsuspensor/M\nsuspicion/GSMD\nsuspicious/YP\nsuspiciousness/M\nsustain/DRGLBS\nsustainability\nsustainable/U\nsustainer/M\nsustainment/M\nsustenance/MS\nsutler/MS\nsuture/GMSD\nsuzerain/SM\nsuzerainty/MS\nsvelte/RPTY\nswab/MS\nswabbed\nswabbing\nswabby/S\nswaddle/SDG\nswag/GMS\nswagged\nswagger/GSDR\nswagging\nswain/SM\nswallow/GDRS\nswallower/M\nswallowtail/SM\nswam\nswami/SM\nswamp/SRDMG\nswamper/M\nswampland/MS\nswampy/RPT\nswan/MS\nswank/RDSGT\nswankily\nswankiness/MS\nswanky/PTRS\nswanlike\nswanned\nswanning\nswap/S\nswappable/U\nswapped\nswapper/SM\nswapping\nsward/MSGD\nswarm/GSRDM\nswarmer/M\nswart/P\nswarthiness/M\nswarthy/RTP\nswash/GSRD\nswashbuckler/SM\nswashbuckling/S\nswastika/SM\nswat/S\nswatch/MS\nswath/SRDMGJ\nswathe\nswather/M\nswaths\nswatted\nswatter/MDSG\nswatting\nsway/DRGS\nswayback/SD\nswayer/M\nswear/SGZR\nswearer/M\nswearword/SM\nsweat/SGZRM\nsweatband/MS\nsweater/M\nsweatily\nsweatiness/M\nsweatpants\nsweatshirt/S\nsweatshop/MS\nsweaty/TRP\nswede/SM\nsweep/SBRJGZ\nsweeper/M\nsweeping/PY\nsweepingness/M\nsweeps/M\nsweepstake's\nsweepstakes\nsweet/TXSYRNPG\nsweetbread/SM\nsweetbrier/SM\nsweetcorn\nsweeten/ZDRGJ\nsweetened/U\nsweetener/M\nsweetening/M\nsweetheart/MS\nsweetie/MS\nsweeting/M\nsweetish/Y\nsweetmeat/MS\nsweetness/MS\nsweetshop\nswell/SJRDGT\nswellhead/DS\nswelling/M\nswelter/DJGS\nsweltering/Y\nswept\nsweptback\nswerve/GSD\nswerving/U\nswift/GTYRDPS\nswifter/M\nswiftness/MS\nswig/SM\nswigged\nswigging\nswill/SDG\nswim/S\nswimmer/MS\nswimming/MYS\nswimsuit/MS\nswindle/GZRSD\nswindler/M\nswine/SM\nswineherd/MS\nswing/SGRZJB\nswingeing\nswinger/M\nswinging/Y\nswingy/R\nswinish/PY\nswinishness/M\nswipe/DSG\nswirl/SGRD\nswirling/Y\nswirly/TR\nswish/GSRD\nswishy/R\nswiss\nswitch/GBZMRSDJ\nswitchback/GDMS\nswitchblade/SM\nswitchboard/MS\nswitcher/M\nswitchgear\nswitchman/M\nswitchmen/M\nswitchover/M\nswivel/GMDS\nswizzle/RDGM\nswob's\nswollen\nswoon/GSRD\nswooning/Y\nswoop/RDSG\nswoosh/GSD\nswop's\nsword/DMSG\nswordfish/SM\nswordplay/RMS\nswordplayer/M\nswordsman/M\nswordsmanship/SM\nswordsmen\nswordtail/M\nswore\nsworn\nswot/S\nswum\nswung\nsybarite/MS\nsybaritic\nsycamore/SM\nsycophancy/S\nsycophant/SYM\nsycophantic\nsycophantically\nsyllabi's\nsyllabic/S\nsyllabicate/GNDSX\nsyllabication/M\nsyllabicity\nsyllabification/M\nsyllabify/GSDXN\nsyllable/SDMG\nsyllabub/M\nsyllabus/MS\nsyllabusss\nsyllogism/MS\nsyllogistic\nsylph/M\nsylphic\nsylphlike\nsylphs\nsylvan/S\nsymbiont/M\nsymbioses\nsymbiosis/M\nsymbiotic\nsymbol/GMDS\nsymbolic/SM\nsymbolical/Y\nsymbolics/M\nsymbolism/MS\nsymbolist/MS\nsymbolization/MAS\nsymbolize/GZRSD\nsymbolized/U\nsymbolizes/A\nsymmetric\nsymmetrical/PY\nsymmetrically/U\nsymmetricalness/M\nsymmetrization/M\nsymmetrizing\nsymmetry/MS\nsympathetic/S\nsympathetically/U\nsympathize/SRDJGZ\nsympathized/U\nsympathizer/M\nsympathizing/MYUS\nsympathy/MS\nsymphonic\nsymphonists\nsymphony/MS\nsymposium/MS\nsymptom/MS\nsymptomatic\nsymptomatically\nsymptomatology/M\nsyn\nsynagogal\nsynagogue/SM\nsynapse/SDGM\nsynaptic\nsync/SGD\nsynchronism/M\nsynchronization's\nsynchronization/SA\nsynchronize/AGCDS\nsynchronized/U\nsynchronizer/MS\nsynchronous/YP\nsynchronousness/M\nsynchrony\nsynchrotron/M\nsyncopate/VNGXSD\nsyncopation/M\nsyncope/MS\nsyndic/SM\nsyndicalist\nsyndicate/XSDGNM\nsyndrome/SM\nsynergism/SM\nsynergistic\nsynergy/MS\nsynfuel/S\nsynod/SM\nsynonym/SM\nsynonymic\nsynonymous/Y\nsynonymy/MS\nsynopses\nsynopsis/M\nsynopsized\nsynopsizes\nsynopsizing\nsynoptic/S\nsyntactic/SY\nsyntactical/Y\nsyntactics/M\nsyntax/MS\nsyntheses\nsynthesis/M\nsynthesize/GZSRD\nsynthesized/U\nsynthesizer/M\nsynthesizes/A\nsynthetic/S\nsynthetically\nsyphilis/MS\nsyphilitic/S\nsyphilized\nsyphilizing\nsyringe/GMSD\nsyrup/DMSG\nsyrupy\nsys\nsystem/MS\nsystematic/SP\nsystematical/Y\nsystematics/M\nsystematization/SM\nsystematize/ZDRSG\nsystematized/U\nsystematizer/M\nsystematizing/U\nsystemic/S\nsystemically\nsystemization/SM\nsystole/MS\nsystolic\nsance/SM\nt/XTJBG\ntab/SM\ntabbed\ntabbing\ntabbouleh\ntabboulehs\ntabby/GSD\ntabernacle/SDGM\ntabla/MS\ntable/GMSD\ntableau/M\ntableaux\ntablecloth/M\ntablecloths\ntableland/SM\ntablespoon/SM\ntablespoonful/MS\ntablet/MDGS\ntabletop/MS\ntableware/SM\ntabling/M\ntabloid/MS\ntaboo/GSMD\ntabor/MDGS\ntabula\ntabular/Y\ntabulate/XNGDS\ntabulation/M\ntabulator/MS\ntachometer/SM\ntachometry\ntachycardia/MS\ntachyon/SM\ntacit/YP\ntacitness/MS\ntaciturn/Y\ntaciturnity/MS\ntack/GZRDMS\ntacker/M\ntackiness/MS\ntackle/RSDMZG\ntackler/M\ntackling/M\ntacky/RSTP\ntaco/MS\ntact/FSM\ntactful/YP\ntactfulness/S\ntactic/SM\ntactical/Y\ntactician/MS\ntactile/Y\ntactility/S\ntactless/PY\ntactlessness/SM\ntactual/Y\ntad/SM\ntadpole/MS\ntaffeta/MS\ntaffrail/SM\ntaffy/SM\ntag/SM\ntagged/U\ntagger/S\ntagging\ntaiga/MS\ntail/CMRDGAS\ntailback/MS\ntailcoat/S\ntailer/AM\ntailgate/MGRSD\ntailgater/M\ntailing/MS\ntailless/P\ntaillessness/M\ntaillight/MS\ntailor/DMJSGB\ntailpipe/SM\ntailspin/MS\ntailwind/SM\ntaint/DGS\ntainted/U\ntake/RSHZGJ\ntakeaway/S\ntaken/A\ntakeoff/SM\ntakeout/S\ntakeover/SM\ntaker/M\ntakes/IA\ntaking/IA\ntalc/SM\ntalcked\ntalcking\ntalcum/S\ntale/RSMN\ntalebearer/SM\ntalent/SMD\ntalented/M\ntalentless\ntaler/M\ntali\ntalion/M\ntalisman/SM\ntalismanic\ntalk/GZSRD\ntalkative/YP\ntalkativeness/MS\ntalker/M\ntalkie/M\ntalky/RST\ntall/TPR\ntallboy/MS\ntallish\ntallness/MS\ntallow/DMSG\ntallowy\ntally/GRSDZ\ntallyho/DMSG\ntalon/SMD\ntalus/MS\ntam/MDRSTZGB\ntamable/M\ntamale/SM\ntamarack/SM\ntamarind/MS\ntambourine/MS\ntame/SYP\ntamed/U\ntameness/S\ntamp/SGZRD\ntamper/ZGRD\ntampered/U\ntamperer/M\ntampon/DMSG\ntan/MS\ntanager/MS\ntanbark/SM\ntandem/SM\ntandoori/S\ntang/GSYDM\ntangelo/SM\ntangency/M\ntangent/SM\ntangential/Y\ntangerine/MS\ntangibility/MIS\ntangible/IPS\ntangibleness's/I\ntangibleness/SM\ntangibly/I\ntangle's\ntangle/UDSG\ntango/MDSG\ntangy/RST\ntank/GZSRDM\ntankard/MS\ntanker/M\ntankful/MS\ntanned/U\ntanner/SM\ntannery/MS\ntannest\ntannin/SM\ntanning/SM\ntansy/SM\ntantalization/SM\ntantalize/GZSRD\ntantalized/U\ntantalizing/YP\ntantalizingly/S\ntantalizingness/S\ntantalum/MS\ntantamount\ntantra/S\ntantrum/SM\ntao/S\ntaoism\ntaoist/S\ntap/MSDRJZG\ntape/SM\ntaped/U\ntapeline/S\ntaper/GRD\ntaperer/M\ntapestry/GMSD\ntapeworm/MS\ntapioca/MS\ntapir/MS\ntapped/U\ntapper/MS\ntappet/MS\ntapping/M\ntaproom/MS\ntaproot/SM\ntaps/M\ntar/GSMD\ntarantella/MS\ntarantula/MS\ntardily\ntardiness/S\ntardy/TPRS\ntare/MS\ntarget/GSMD\ntariff/DMSG\ntarmac/S\ntarmacked\ntarmacking\ntarn/MS\ntarnish/GDS\ntarnished/U\ntaro/MS\ntarot/MS\ntarp/MS\ntarpapered\ntarpaulin/MS\ntarpon/MS\ntarragon/SM\ntarred/M\ntarring/M\ntarry/TGRSD\ntarsal/S\ntarsi\ntarsus/M\ntart/PMYRDGTS\ntartan/MS\ntartar/SM\ntartaric\ntartness/MS\ntask/GSDM\ntaskmaster/SM\ntaskmistress/MS\ntassel/MDGS\ntassellings\ntaste's/E\ntaste/GZMJSRD\ntasted/EU\ntasteful/PEY\ntastefulness/SME\ntasteless/YP\ntastelessness/SM\ntaster/M\ntastes/E\ntastily\ntastiness/MS\ntasting/E\ntasty/RTP\ntat/SRZ\ntatami/MS\ntater/M\ntatted\ntatter/GDS\ntatterdemalion/SM\ntattered/M\ntatting/SM\ntattle/RSDZG\ntattler/M\ntattletale/SM\ntattoo/ZRDMGS\ntattooer/M\ntattooist/MS\ntatty/R\ntau/SM\ntaught/AU\ntaunt/ZGRDS\ntaunter/M\ntaunting/Y\ntaupe/SM\ntaut/PGTXYRDNS\ntauten/GD\ntautness/S\ntautological/Y\ntautologous\ntautology/SM\ntavern/RMS\ntaverner/M\ntawdrily\ntawdriness/SM\ntawdry/SRTP\ntawny/RSMPT\ntax/ZGJMDRSB\ntaxable/S\ntaxably\ntaxation/MS\ntaxed/U\ntaxi/MDGS\ntaxicab/MS\ntaxidermist/SM\ntaxidermy/MS\ntaximeter/SM\ntaxing/Y\ntaxiway/MS\ntaxonomic\ntaxonomically\ntaxonomist/SM\ntaxonomy/SM\ntaxpayer/MS\ntaxpaying/M\ntbs\ntbsp\ntea/MDGS\nteabag/S\nteacake/MS\nteacart/M\nteach/AGS\nteachable/P\nteacher/MS\nteaching/SM\nteacloth\nteacup/MS\nteacupful/MS\nteahouse/SM\nteak/SM\nteakettle/SM\nteakwood/M\nteal/MS\ntealeaves\nteam/MRDGS\nteammate/MS\nteamster/MS\nteamwork/SM\nteapot/MS\ntear/RDMSG\ntearaway\nteardrop/MS\ntearer/M\ntearful/YP\ntearfulness/M\nteargas/S\nteargassed\nteargassing\ntearjerker/S\ntearoom/MS\nteary/RT\nteas/SRDGZ\ntease/KS\nteasel/DGSM\nteaser/M\nteashop/SM\nteasing/Y\nteaspoon/MS\nteaspoonful/MS\nteat/MDS\nteatime/MS\ntech/D\ntechnetium/SM\ntechnical/YSP\ntechnicality/MS\ntechnicalness/M\ntechnician/MS\ntechnique/SM\ntechnocracy/MS\ntechnocrat/S\ntechnocratic\ntechnological/Y\ntechnologist/MS\ntechnology/MS\ntechnophobia\ntechnophobic\ntechs\ntectonic/S\ntectonically\ntectonics/M\nteddy/SM\ntedious/YP\ntediousness/SM\ntedium/MS\ntee/DRSMH\nteeing\nteem/GSD\nteeming/PY\nteemingness/M\nteen/SR\nteenage/RZ\nteenager/M\nteeny/RT\nteenybopper/SM\nteepee's\nteeshirt/S\nteeter/GDS\nteeth/RSDJMG\nteethe\nteether/M\nteething/M\nteethmarks\nteetotal/SRDGZ\nteetotaler/M\nteetotalism/MS\ntektite/SM\ntel/SY\ntelecast/SRGZ\ntelecommunicate/NX\ntelecommunication/M\ntelecommute/SRDZGJ\ntelecoms\nteleconference/GMJSD\ntelegenic\ntelegram/MS\ntelegrammed\ntelegramming\ntelegraph/MRDGZ\ntelegraphic\ntelegraphically\ntelegraphist/MS\ntelegraphs\ntelegraphy/MS\ntelekineses\ntelekinesis/M\ntelekinetic\ntelemarketer/S\ntelemarketing/S\ntelemeter/DMSG\ntelemetric\ntelemetry/MS\nteleological/Y\nteleology/M\ntelepathic\ntelepathically\ntelepathy/SM\ntelephone/SRDGMZ\ntelephonic\ntelephonist/SM\ntelephony/MS\ntelephoto/S\ntelephotography/MS\nteleprinter/MS\nteleprocessing/S\nteleprompter\ntelescope/GSDM\ntelescopic\ntelescopically\nteletext/S\ntelethon/MS\nteletype/SM\nteletypewriter/SM\ntelevangelism/S\ntelevangelist/S\ntelevise/SDXNG\ntelevision/M\ntelevisor/MS\ntelevisual\ntelex/GSDM\ntell/AGS\nteller/SDMG\ntelling/YS\ntelltale/MS\ntellurium/SM\ntelly/SM\ntelnet/S\ntelomeric\ntemblor/SM\ntemerity/MS\ntemp/SGZTMRD\ntemper's/E\ntemper/GRDM\ntempera/SLM\ntemperament/SM\ntemperamental/Y\ntemperance/IMS\ntemperate/SDGPY\ntemperately/I\ntemperateness's/I\ntemperateness/SM\ntemperature/MS\ntempered/UE\ntempering/E\ntempers/E\ntempest/DMSG\ntempestuous/PY\ntempestuousness/SM\ntemplate's\ntemplate/FS\ntemple/SDM\ntempo/MS\ntempoes\ntemporal/YS\ntemporarily\ntemporariness/FM\ntemporarinesses\ntemporary/SFP\ntemporize/GJZRSD\ntemporizer/M\ntemporizing/YM\ntemporizings/U\ntempt/FS\ntemptation/MS\ntempted\ntempter/S\ntempting/YS\ntemptress/MS\ntempura/SM\nten/MHB\ntenabilities\ntenability/UM\ntenable/P\ntenableness/M\ntenably\ntenacious/YP\ntenaciousness/S\ntenacity/S\ntenancy/MS\ntenant/MDSG\ntenanted/U\ntenantry/MS\ntench/M\ntend/ISFRDG\ntended/UE\ntendency/MS\ntendentious/PY\ntendentiousness/SM\ntender/FS\ntendered\ntenderer\ntenderest\ntenderfoot/MS\ntenderhearted/YP\ntenderheartedness/MS\ntendering\ntenderize/SRDGZ\ntenderizer/M\ntenderloin/SM\ntenderly\ntenderness/SM\ntending/E\ntendinitis/S\ntendon/MS\ntendril/SM\ntends/E\ntenebrous\ntenement/MS\ntenet/SM\ntenfold/S\ntenner\ntennis/SM\ntenon/GSMD\ntenor/MS\ntenpin/SM\ntens/SRDVGT\ntense/IPYTNVR\ntenseness's/I\ntenseness/SM\ntensile\ntension's/I\ntension/GMRDS\ntensional/I\ntensionless\ntensions/E\ntensity/IMS\ntensor/MS\ntensorial\ntenspot\ntent/FSIM\ntentacle/MSD\ntentative/SPY\ntentativeness/S\ntented/UF\ntenter/M\ntenterhook/MS\ntenth/SY\ntenths\ntenting/F\ntenuity/S\ntenuous/YP\ntenuousness/SM\ntenure/SDM\ntepee/MS\ntepid/YP\ntepidity/S\ntepidness/S\ntequila/SM\nteratogenic\nteratology/MS\nterbium/SM\ntercel/M\ntercentenary/S\ntercentennial/S\nterm/MYRDGS\ntermagant/SM\ntermcap\ntermer/M\nterminable/CPI\nterminableness/IMC\nterminal/SYM\nterminate/CXNV\nterminated/U\nterminates\nterminating\ntermination/MC\nterminative/YC\nterminator/SM\ntermini\nterminological/Y\nterminology/MS\nterminus/M\ntermite/SM\ntern's\ntern/GIDS\nternary/S\nterpsichorean\nterr/S\nterrace/MGSD\nterracing/M\nterracotta\nterrain/MS\nterramycin\nterrapin/MS\nterrarium/MS\nterrazzo/SM\nterrestrial/YMS\nterrible/P\nterribleness/SM\nterribly\nterrier/M\nterrific/Y\nterrifically\nterrify/GDS\nterrifying/Y\nterrine/M\nterritorial/SY\nterritoriality/M\nterritory/SM\nterror/MS\nterrorism/MS\nterrorist/MS\nterroristic\nterrorize/RSDZG\nterrorized/U\nterrorizer/M\nterry/ZMRS\nterrycloth\nterse/RTYP\nterseness/SM\ntertian\ntertiary/S\ntessellate/XDSNG\ntessellation/M\ntesseral\ntest's/AKF\ntest/RDBFZGSC\ntestability/M\ntestable/U\ntestament/SM\ntestamentary\ntestate/IS\ntestator/MS\ntestatrices\ntestatrix\ntestbed/S\ntestcard\ntested/AKU\ntester/MFCKS\ntestes/M\ntesticle/SM\ntesticular\ntestifier/M\ntestify/GZDRS\ntestily\ntestimonial/SM\ntestimony/SM\ntestiness/S\ntesting/S\ntestis/M\ntestosterone/SM\ntests/AK\ntesty/RTP\ntetanus/MS\ntetchy/TR\ntether/DMSG\ntethered/U\ntetra/MS\ntetrachloride/M\ntetracycline/SM\ntetrafluoride\ntetragonal/Y\ntetrahalides\ntetrahedral/Y\ntetrahedron/SM\ntetrameron\ntetrameter/SM\ntetrasodium\ntetravalent\ntext/FSM\ntextbook/SM\ntextile/SM\ntextual/FY\ntextural/Y\ntexture/MGSD\ntextured/U\nth/GNJX\nthalami\nthalamus/M\nthalidomide/MS\nthallium/SM\nthallophyte/M\nthan\nthane/SM\nthank/SRDG\nthanker/M\nthankful/YP\nthankfuller\nthankfullest\nthankfulness/SM\nthankless/PY\nthanklessness/SM\nthanksgiving/MS\nthat'd\nthat'll\nthat/MS\nthatch/JMDRSZG\nthatching/M\nthaumaturge/M\nthaw/DGS\nthe\ntheater/SM\ntheatergoer/MS\ntheatergoing/MS\ntheatric/S\ntheatrical/YS\ntheatricality/SM\ntheatrics/M\nthee/DS\ntheeing\ntheft/MS\ntheir/MS\ntheism/SM\ntheist/SM\ntheistic\nthem/GD\nthemas\nthematic/U\nthematically\nthematics\ntheme/MS\nthemselves\nthence\nthenceforth\nthenceforward/S\ntheocracy/SM\ntheocratic\ntheodolite/MS\ntheologian/SM\ntheological/Y\ntheologists\ntheology/MS\ntheorem/MS\ntheoretic/S\ntheoretical/Y\ntheoretician/MS\ntheoretics/M\ntheorist/SM\ntheorization/SM\ntheorize/ZGDRS\ntheory/MS\ntheosophic\ntheosophical\ntheosophist/MS\ntheosophy/SM\ntherapeutic/S\ntherapeutically\ntherapeutics/M\ntherapist/MS\ntherapy/MS\nthere'd\nthere'll\nthere/MS\nthereabout/S\nthereafter\nthereat\nthereby\ntherefor\ntherefore\ntherefrom\ntherein\nthereof\nthereon\nthereto\ntheretofore\nthereunder\nthereunto\nthereupon\ntherewith\ntherm/MS\nthermal/YS\nthermionic/S\nthermionics/M\nthermistor/MS\nthermo/S\nthermocouple/MS\nthermodynamic/S\nthermodynamical/Y\nthermodynamics/M\nthermoelastic\nthermoelectric\nthermoformed\nthermoforming\nthermogravimetric\nthermoluminescence/M\nthermometer/MS\nthermometric\nthermometry/M\nthermonuclear\nthermopile/M\nthermoplastic/S\nthermopower\nthermos/S\nthermosetting\nthermostable\nthermostat/SM\nthermostatic/S\nthermostatically\nthermostatics/M\nthermostatted\nthermostatting\nthesauri\nthesaurus/MS\nthese/S\nthesis/M\nthespian/S\ntheta/MS\nthew/SM\nthey\nthey'd\nthey'll\nthey're\nthey've\nthiamine/MS\nthick/TXPSRNY\nthicken/RDJZG\nthickener/M\nthickening/M\nthicket/SMD\nthickheaded/M\nthickish\nthickness/MS\nthickset/S\nthief/M\nthieve/SDJG\nthievery/MS\nthievish/P\nthievishness/M\nthigh/DM\nthighbone/SM\nthighs\nthimble/DSMG\nthimbleful/MS\nthin/STPYR\nthine\nthing/MP\nthingamabob/MS\nthingamajig/SM\nthink/AGRS\nthinkable/U\nthinkableness/M\nthinkably/U\nthinker/MS\nthinking/SMYP\nthinkingly/U\nthinned\nthinner/MS\nthinness/MS\nthinnest\nthinning\nthinnish\nthiocyanate/M\nthiouracil/M\nthird/DYGS\nthirst/GSMDR\nthirster/M\nthirstily\nthirstiness/S\nthirsty/TPR\nthirteen/MHS\nthirteenths\nthirtieths\nthirty/HMS\nthis\nthis'll\nthistle/SM\nthistledown/MS\nthither\ntho\nthole/GMSD\nthong/SMD\nthoracic\nthorax/MS\nthoriate/D\nthorium/MS\nthorn/SMDG\nthorniness/S\nthorny/PTR\nthorough/PTYR\nthoroughbred/S\nthoroughfare/MS\nthoroughgoing\nthoroughness/SM\nthose\nthou/DSG\nthough\nthought/MS\nthoughtful/U\nthoughtfully\nthoughtfulness/S\nthoughtless/YP\nthoughtlessness/MS\nthousand/SHM\nthousandfold\nthousandths\nthrall/GSMD\nthralldom/S\nthrash/DSRZGJ\nthrasher/M\nthrashing/M\nthread/MZDRGS\nthreadbare/P\nthreader/M\nthreading/A\nthreadlike\nthready/RT\nthreat/MDNSXG\nthreaten/GJRD\nthreatener/M\nthreatening/Y\nthree/MS\nthreefold\nthreepence/M\nthreepenny\nthreescore/S\nthreesome/SM\nthrenody/SM\nthresh/DSRZG\nthresher/M\nthreshold/MDGS\nthrew\nthrice\nthrift/SM\nthriftily\nthriftiness/S\nthriftless\nthrifty/PTR\nthrill/ZMGDRS\nthriller/M\nthrilling/Y\nthrive/RSDJG\nthriver/M\nthriving/Y\nthroat/MDSG\nthroatily\nthroatiness/MS\nthroaty/PRT\nthrob/S\nthrobbed\nthrobbing\nthroe/SDM\nthroeing\nthrombi\nthromboses\nthrombosis/M\nthrombotic\nthrombus/M\nthrone's\nthrone/CGSD\nthrong/GDSM\nthrottle/DRSZMG\nthrottler/M\nthrough/Y\nthroughout\nthroughput/SM\nthroughway's\nthrow/SZGR\nthrowaway/SM\nthrowback/MS\nthrower/M\nthrown\nthrowout\nthrum/S\nthrummed\nthrumming\nthrush/MS\nthrust/ZGSR\nthruster/M\nthruway/SM\nthud/MS\nthudded\nthudding\nthug/MS\nthuggee/M\nthuggery/SM\nthuggish\nthulium/SM\nthumb/SMDG\nthumbnail/MS\nthumbscrew/SM\nthumbtack/GMDS\nthump/RDMSG\nthunder/ZGJDRMS\nthunderbolt/MS\nthunderclap/SM\nthundercloud/SM\nthunderer/M\nthunderhead/SM\nthundering/Y\nthunderous/Y\nthundershower/MS\nthunderstorm/MS\nthunderstruck\nthundery\nthunk\nthus/Y\nthwack/DRSZG\nthwacker/M\nthwart/GSDRY\nthwarter/M\nthy\nthyme/SM\nthymine/MS\nthymus/SM\nthyratron/M\nthyristor/MS\nthyroglobulin\nthyroid/S\nthyroidal\nthyronine\nthyrotoxic\nthyrotrophic\nthyrotrophin\nthyrotropic\nthyrotropin/M\nthyroxine/M\nthyself\nti/MDRZ\ntiara/MS\ntibia/M\ntibiae\ntibial\ntic/MS\ntick/GZJRDMS\nticker/M\nticket/SGMD\nticking/M\ntickle/RSDZG\ntickler/M\nticklish/PY\nticklishness/MS\nticktacktoe/S\nticktock/SMDG\ntidal/Y\ntidbit/MS\ntiddlywinks/M\ntide/GJDS\ntideland/MS\ntidewater/SM\ntideway/SM\ntidily/U\ntidiness/USM\ntidy/UGDSRPT\ntidying/M\ntie/AUDS\ntieback/MS\ntiebreaker/SM\ntier/DGM\ntiff/GDMS\ntiffany/M\ntiger/SM\ntigerish\ntight/STXPRNY\ntighten/JZGDR\ntightener/M\ntightfisted\ntightness/MS\ntightrope/SM\ntightwad/MS\ntigress/SM\ntike's\ntilde/MS\ntile/DRSJMZG\ntiled/UE\ntiles/U\ntiling/M\ntill/EGSZDR\ntillable\ntillage/SM\ntiller's/E\ntiller/GDM\ntilt/RDSGZ\ntilth/M\ntimber/DMSG\ntimbering/M\ntimberland/SM\ntimberline/S\ntimbre/MS\ntimbrel/SM\ntime/DRSJMYZG\ntimebase\ntimekeeper/MS\ntimekeeping/SM\ntimeless/PY\ntimelessness/S\ntimeliness/SMU\ntimely/UTRP\ntimeout/S\ntimepiece/MS\ntimer/M\ntimescale/S\ntimeserver/MS\ntimeserving/S\ntimeshare/SDG\ntimespan\ntimestamped\ntimestamps\ntimetable/GMSD\ntimeworn\ntimezone/S\ntimid/RYTP\ntimidity/SM\ntimidness/MS\ntiming/M\ntimorous/YP\ntimorousness/MS\ntimothy/MS\ntimpani\ntimpanist/S\ntin/MDGS\ntincture/SDMG\ntinder/MS\ntinderbox/MS\ntine/SM\ntinfoil/MS\nting/GYDM\ntinge/S\ntingeing\ntingle/SDG\ntingling/Y\ntingly/TR\ntinily\ntininess/MS\ntinker/SRDMZG\ntinkle/SDG\ntinkling/M\ntinkly\ntinned\ntinner/M\ntinnily\ntinniness/SM\ntinning/M\ntinnitus/MS\ntinny/RSTP\ntinplate/S\ntinsel/GMDYS\ntinsmith/M\ntinsmiths\ntint/SGMRDB\ntinter/M\ntintinnabulation/MS\ntintype/SM\ntinware/MS\ntiny/RPT\ntip/MS\ntipi's\ntipoff\ntipped\ntipper/MS\ntippet/MS\ntipping\ntipple/ZGRSD\ntippler/M\ntippy/R\ntipsily\ntipsiness/SM\ntipster/SM\ntipsy/TPR\ntiptoe/SD\ntiptoeing\ntiptop/S\ntirade/SM\ntire/MGDSJ\ntired/AYP\ntireder\ntiredest\ntiredness/S\ntireless/PY\ntirelessness/SM\ntires/A\ntiresome/PY\ntiresomeness/S\ntiring/AU\ntiro's\ntis\ntissue/MGSD\ntit/MRZS\ntitan/SM\ntitanate/M\ntitanic\ntitanically\ntitanium/SM\ntitbit's\ntiter/M\ntithe/SRDGZM\ntither/M\ntithing/M\ntitian/S\ntitillate/XSDVNG\ntitillating/Y\ntitillation/M\ntitivate/NGDSX\ntitivation/M\ntitle/GMSRD\ntitled/AU\ntitleholder/SM\ntitling/A\ntitmice\ntitmouse/M\ntitrate/SDGN\ntitration/M\ntitted\ntitter/GDS\ntitting\ntittle/SDMG\ntitular/SY\ntizzy/SM\ntn\ntnpk\nto/D\ntoad/SM\ntoadstool/SM\ntoady/GSDM\ntoadyism/M\ntoast/SZGRDM\ntoaster/M\ntoastmaster/MS\ntoastmistress/S\ntoasty/TRS\ntobacco/SM\ntobacconist/SM\ntobaggon/SM\ntoboggan/MRDSZG\ntoccata/M\ntocsin/MS\ntoday'll\ntoday/SM\ntoddle/ZGSRD\ntoddler/M\ntoddy/SM\ntoe/MS\ntoecap/SM\ntoeclip/S\ntoehold/MS\ntoeing\ntoenail/DMGS\ntoffee/SM\ntofu/S\ntog/SMG\ntoga/SMD\ntoge\ntogether/P\ntogetherness/MS\ntogged\ntogging\ntoggle/SDMG\ntoil/SGZMRD\ntoilet/GMDS\ntoiletry/MS\ntoilette/SM\ntoilsome/PY\ntoilsomeness/M\ntokamak\ntoke/GDS\ntoken/SMDG\ntokenism/SM\ntokenized\ntold/AU\ntole/MGDS\ntolerability/IM\ntolerable/I\ntolerably/I\ntolerance/SIM\ntolerant/IY\ntolerate/XVNGSD\ntoleration/M\ntoll/DGS\ntollbooth/M\ntollbooths\ntollgate/MS\ntollhouse/M\ntollway/S\ntoluene/MS\ntom/SM\ntomahawk/SGMD\ntomato/M\ntomatoes\ntomb/GSDM\ntomblike\ntombola/M\ntomboy/MS\ntomboyish\ntombstone/MS\ntomcat/SM\ntomcatted\ntomcatting\ntome/SM\ntomfool/M\ntomfoolery/MS\ntommed\ntomming\ntommy/M\ntomographic\ntomography/MS\ntomorrow/MS\ntomtit/SM\nton/SKM\ntonal/Y\ntonality/MS\ntone's\ntone/ISRDZG\ntonearm/S\ntoneless/YP\ntonelessness/M\ntoner/IM\ntong/GRDS\ntongue/SDMG\ntongueless\ntonguing/M\ntonic/SM\ntonight/MS\ntonk/MS\ntonnage/SM\ntonne/MS\ntonsil/SM\ntonsillectomy/MS\ntonsillitis/SM\ntonsorial\ntonsure/SDGM\ntony/RT\ntoo/H\ntoodle\ntook/A\ntool's\ntool/AGDS\ntoolbox/SM\ntooler/SM\ntooling/M\ntoolkit/SM\ntoolmake/ZRG\ntoolmaker/M\ntoolmaking/M\ntoolsmith\ntoot/GRDZS\ntooter/M\ntooth/DMG\ntoothache/SM\ntoothbrush/MSG\ntoothily\ntoothless\ntoothmarks\ntoothpaste/SM\ntoothpick/MS\ntooths\ntoothsome\ntoothy/TR\ntootle/SRDG\ntoots/M\ntootsie\ntootsy/MS\ntop/SMDRG\ntopaz/MS\ntopcoat/MS\ntopdressing/S\ntoper/M\ntopflight\ntopgallant/M\ntopiary/S\ntopic/MS\ntopical/Y\ntopicality/MS\ntopknot/MS\ntopless\ntopmast/MS\ntopmost\ntopnotch/R\ntopocentric\ntopographer/SM\ntopographic\ntopographical/Y\ntopography/MS\ntopological/Y\ntopologist/MS\ntopology/MS\ntopped\ntopper/MS\ntopping/MS\ntopple/GSD\ntopsail/MS\ntopside/SRM\ntopsoil/GDMS\ntopspin/MS\ntoque/MS\ntor/SLM\ntorch/SDMG\ntorchbearer/SM\ntorchlight/S\ntore/S\ntoreador/SM\ntori/M\ntorment/GSD\ntormenting/Y\ntormentor/MS\ntorn\ntornado/M\ntornadoes\ntoroid/MS\ntoroidal/Y\ntorpedo/GMD\ntorpedoes\ntorpid/SY\ntorpidity/S\ntorpor/MS\ntorque/MZGSRD\ntorrence\ntorrent/MS\ntorrential\ntorrid/RYTP\ntorridity/SM\ntorridness/SM\ntors/S\ntorsi's\ntorsion/IAM\ntorsional/Y\ntorsions\ntorso/SM\ntort's\ntort/ASFE\ntorte/MS\ntortellini/MS\ntorten\ntortilla/MS\ntortoise/SM\ntortoiseshell/SM\ntortoni/MS\ntortuous/PY\ntortuousness/MS\ntorture/ZGSRD\ntorturous\ntorus/MS\ntoss/SRDGZ\ntossup/MS\ntot/MDRSG\ntotal/ZGSRDYM\ntotaler/M\ntotalistic\ntotalitarian/S\ntotalitarianism/SM\ntotality/MS\ntotalizator/S\ntotalizing\ntote/S\ntotem/MS\ntotemic\ntoter/M\ntoting/M\ntotted\ntotter/ZGRDS\ntotterer/M\ntottering/Y\ntotting\ntoucan/MS\ntouch/ASDG\ntouchable/U\ntouchdown/SM\ntouched/U\ntoucher/M\ntouchily\ntouchiness/SM\ntouching/SY\ntouchline/M\ntouchscreen\ntouchstone/SM\ntouchy/TPR\ntouch\ntough/TXGRDNYP\ntoughen/DRZG\ntoughener/M\ntoughness/SM\ntoughs\ntoupee/SM\ntour's/CF\ntour/GZSRDM\ntoured/CF\ntourer/M\ntouring/F\ntourism/SM\ntourist/SM\ntouristic\ntouristy\ntourmaline/SM\ntournament/MS\ntourney/GDMS\ntourniquet/MS\ntours/CF\ntousle/GSD\ntout/SGRD\ntouter/M\ntow/DRSZG\ntoward/YU\ntowardliness/M\ntowardly/P\ntowards\ntowboat/MS\ntowel/GJDMS\ntowelette/S\ntoweling/M\ntower/GMD\ntowering/Y\ntowhead/MSD\ntowhee/SM\ntowline/MS\ntown/SRM\ntowner/M\ntownhouse/S\ntownie/S\ntownsfolk\ntownship/MS\ntownsman/M\ntownsmen\ntownspeople/M\ntownswoman/M\ntownswomen\ntowpath/M\ntowpaths\ntowrope/MS\ntoxemia/MS\ntoxic/S\ntoxicity/MS\ntoxicological\ntoxicologist/SM\ntoxicology/MS\ntoxin/MS\ntoy/MDRSG\ntoyer/M\ntoymaker\ntoyshop\ntr\ntrace's\ntrace/ASDG\ntraceability/M\ntraceable/P\ntraceableness/M\ntraceback/MS\ntraced/U\ntraceless/Y\ntracepoint/SM\ntracer/MS\ntracery/MDS\ntrachea/M\ntracheae\ntracheal/M\ntracheotomy/SM\ntracing/SM\ntrack/SZGMRD\ntrackage\ntrackball/S\ntrackbed\ntracked/U\ntracker/M\ntrackless\ntracksuit/SM\ntract's\ntract/ABS\ntractability/SI\ntractable/I\ntractably/I\ntraction/KSCEMAF\ntractive/KFE\ntractor/FKMASC\ntracts/CEFK\ntrade/SRDGZM\ntrademark/GSMD\ntrader/M\ntradesman/M\ntradesmen\ntradespeople\ntradespersons\ntradeswoman/M\ntradeswomen\ntradition/SM\ntraditional/U\ntraditionalism/MS\ntraditionalist/MS\ntraditionalistic\ntraditionalized\ntraditionally\ntraduce/DRSGZ\ntraffic/SM\ntrafficked\ntrafficker/MS\ntrafficking/S\ntragedian/SM\ntragedienne/MS\ntragedy/MS\ntragic/S\ntragically\ntragicomedy/SM\ntragicomic\ntrail/SZGJRD\ntrailblazer/MS\ntrailblazing/S\ntrailer/GDM\ntrails/F\ntrailside\ntrain/ASDG\ntrainable\ntrained/U\ntrainee/MS\ntraineeships\ntrainer/MS\ntraining/SM\ntrainman/M\ntrainmen\ntrainspotter/S\ntraipse/DSG\ntrait/MS\ntraitor/SM\ntraitorous/Y\ntrajectory/MS\ntram/MS\ntrammed\ntrammel/GSD\ntrammeled/U\ntramming\ntramp/RDSZG\ntrample/DGRSZ\ntrampler/M\ntrampoline/GMSD\ntramway/M\ntrance/MGSD\ntranche/SM\ntranquil/PTRY\ntranquility/S\ntranquilize/JGZDSR\ntranquilized/U\ntranquilizer/M\ntranquilizes/A\ntranquilizing/YM\ntranquillize/GRSDZ\ntranquillizer/M\ntranquilness/M\ntrans/I\ntransact/GSD\ntransaction/MS\ntransactional\ntransactor/SM\ntransalpine\ntransaminase\ntransatlantic\ntransceiver/SM\ntranscend/SDG\ntranscendence/MS\ntranscendent/Y\ntranscendental/YS\ntranscendentalism/SM\ntranscendentalist/SM\ntransconductance\ntranscontinental\ntranscribe/DSRGZ\ntranscriber/M\ntranscript/SM\ntranscription/SM\ntranscultural\ntransducer/SM\ntransduction/M\ntransect/DSG\ntransept/SM\ntransfer/BSMD\ntransferability/M\ntransferal/MS\ntransferee/M\ntransference/SM\ntransferor/MS\ntransferral/SM\ntransferred\ntransferrer/SM\ntransferring\ntransfiguration/SM\ntransfigure/SDG\ntransfinite/Y\ntransfix/SDG\ntransform/DRZBSG\ntransformation/MS\ntransformational\ntransformed/U\ntransformer/M\ntransfuse/XSDGNB\ntransfusion/M\ntransgress/VGSD\ntransgression/SM\ntransgressor/S\ntransience/SM\ntransiency/S\ntransient/YS\ntransistor/SM\ntransistorize/GDS\ntransit/SGVMD\ntransition/MDGS\ntransitional/Y\ntransitive/PIY\ntransitiveness/IM\ntransitivenesses\ntransitivity/MS\ntransitoriness/M\ntransitory/P\ntransl\ntranslatability/M\ntranslatable/U\ntranslate/VGNXSDB\ntranslated/AU\ntranslation/M\ntranslational\ntranslator/SM\ntransliterate/XNGSD\ntranslucence/SM\ntranslucency/MS\ntranslucent/Y\ntransmigrate/XNGSD\ntransmissible\ntransmission/MSA\ntransmissive\ntransmit/AS\ntransmittable\ntransmittal/SM\ntransmittance/MS\ntransmitted/A\ntransmitter/SM\ntransmitting/A\ntransmogrification/M\ntransmogrify/GXDSN\ntransmutation/SM\ntransmute/GBSD\ntransnational/S\ntransoceanic\ntransom/SM\ntransonic\ntranspacific\ntransparency/MS\ntransparent/YP\ntransparentness/M\ntranspiration/SM\ntranspire/GSD\ntransplant/GRDBS\ntransplantation/S\ntranspolar\ntransponder/MS\ntransport/BGZSDR\ntransportability\ntransportable/U\ntransportation/SM\ntranspose/BGSD\ntransposed/U\ntransposition/SM\ntranssexual/SM\ntranssexualism/MS\ntransship/LS\ntransshipment/SM\ntransshipped\ntransshipping\ntransubstantiation/MS\ntransversal/YM\ntransverse/GYDS\ntransvestism/SM\ntransvestite/SM\ntransvestitism\ntrap/MS\ntrapdoor/S\ntrapeze/DSGM\ntrapezium/MS\ntrapezoid/MS\ntrapezoidal\ntrappable/U\ntrapped\ntrapper/SM\ntrapping/S\ntrapshooting/SM\ntrash/SRDMG\ntrashcan/SM\ntrashiness/SM\ntrashy/TRP\ntrauma/MS\ntraumatic\ntraumatically\ntraumatize/SDG\ntravail/SMDG\ntravel/SDRGZJ\ntraveled/U\ntraveler/M\ntravelog's\ntravelogue/S\ntraversal/SM\ntraverse/GBDRS\ntraverser/M\ntravertine/M\ntravesty/SDGM\ntrawl/RDMSZG\ntrawler/M\ntray/SM\ntreacherous/PY\ntreacherousness/SM\ntreachery/SM\ntreacle/DSGM\ntreacly\ntread/SAGD\ntreader/M\ntreadle/GDSM\ntreadmill/MS\ntreas\ntreason/BMS\ntreasonous\ntreasure/DRSZMG\ntreasurer/M\ntreasurership\ntreasury/SM\ntreat's\ntreat/SAGDR\ntreatable\ntreated/U\ntreater/S\ntreatise/MS\ntreatment/MS\ntreaty/MS\ntreble/SDG\ntree/MDS\ntreeing\ntreeless\ntreelike\ntreetop/SM\ntrefoil/SM\ntrek/MS\ntrekked\ntrekker/MS\ntrekking\ntrellis/GDSM\ntrematode/SM\ntremble/JDRSG\ntrembler/M\ntrembles/M\ntrembly\ntremendous/YP\ntremendousness/M\ntremolo/MS\ntremor/MS\ntremulous/YP\ntremulousness/SM\ntrench's\ntrench/GASD\ntrenchancy/MS\ntrenchant/Y\ntrencher/SM\ntrencherman/M\ntrenchermen\ntrend/SDMG\ntrendily\ntrendiness/S\ntrendy/PTRS\ntrepanned\ntrepidation/MS\ntrespass/ZRSDG\ntrespasser/M\ntress/MSDG\ntressed/E\ntresses/E\ntressing/E\ntrestle/MS\ntrey/MS\ntriable/P\ntriableness/M\ntriad/MS\ntriadic\ntriage/SDMG\ntrial/ASM\ntrialization\ntrialled\ntrialling\ntriamcinolone\ntriangle/SM\ntriangulable\ntriangular/Y\ntriangularization/S\ntriangulate/YGNXSD\ntriangulation/M\ntriathlon/S\ntriatomic\ntribal/Y\ntribalism/MS\ntribe/MS\ntribesman/M\ntribesmen\ntribeswoman\ntribeswomen\ntribulate/NX\ntribulation/M\ntribunal/MS\ntribune/SM\ntributary/MS\ntribute's\ntribute/EGSF\ntrice/GSDM\ntricentennial/S\ntriceps/SM\ntriceratops/M\ntrichina/M\ntrichinae\ntrichinoses\ntrichinosis/M\ntrichloroacetic\ntrichloroethane\ntrichotomy/M\ntrichromatic\ntrick/GMSRD\ntrickery/MS\ntrickily\ntrickiness/SM\ntrickle/DSG\ntrickster/MS\ntricky/RPT\ntricolor/SMD\ntricycle/SDMG\ntrident/SM\ntridiagonal\ntried/UA\ntriennial/SY\ntrier's\ntrier/AS\ntries/A\ntriffid/S\ntrifle/MZGJSRD\ntrifler/M\ntrifluoride/M\ntrifocals\ntrig/S\ntrigged\ntrigger/GSDM\ntriggest\ntrigging\ntriglyceride/MS\ntrigonal/Y\ntrigonometric\ntrigonometrical\ntrigonometry/MS\ntrigram/S\ntrihedral\ntrike/GMSD\ntrilateral/S\ntrilby/SM\ntrilingual\ntrill/RDMGS\ntrillion/SMH\ntrillionth/M\ntrillionths\ntrillium/SM\ntrilobite/MS\ntrilogy/MS\ntrim/PSYR\ntrimaran/MS\ntrimer/M\ntrimester/MS\ntrimmed/U\ntrimmer/MS\ntrimmest\ntrimming/MS\ntrimness/S\ntrimodal\ntrimonthly\ntrinitarian/S\ntrinitrotoluene/SM\ntrinity/MS\ntrinket/MRDSG\ntrinketer/M\ntrio/SM\ntriode/MS\ntrioxide/M\ntrip/SMY\ntripartite/N\ntripartition/M\ntripe/MS\ntriphenylarsine\ntriphenylphosphine\ntriphenylstibine\ntriphosphopyridine\ntriple/GSD\ntriplet/SM\ntriplex/S\ntriplicate/SDG\ntriplication/M\ntriply/GDSN\ntripod/MS\ntripodal\ntripoli/M\ntripolyphosphate\ntripos/SM\ntripped\ntripper/MS\ntripping/Y\ntriptych/M\ntriptychs\ntripwire/MS\ntrireme/SM\ntrisect/GSD\ntrisection/S\ntrisector\ntrisodium\ntristate\ntrisyllable/M\ntrite/SRPTY\ntritely/F\ntriteness/SF\ntritium/MS\ntriton/M\ntriumph/GMD\ntriumphal\ntriumphalism\ntriumphant/Y\ntriumphs\ntriumvir/MS\ntriumvirate/MS\ntriune\ntrivalent\ntrivet/SM\ntrivia\ntrivial/Y\ntriviality/MS\ntrivialization/MS\ntrivialize/DSG\ntrivium/M\ntrochaic/S\ntrochee/SM\ntrod/AU\ntrodden/UA\ntrodes\ntroff/MR\ntroglodyte/MS\ntroika/SM\ntroll/DMSG\ntrolled/F\ntrolley/SGMD\ntrolleybus/S\ntrolling/F\ntrollish\ntrollop/GSMD\ntrolly's\ntrombone/MS\ntrombonist/SM\ntromp/DSG\ntroop/SRDMZG\ntrooper/M\ntroopship/SM\ntrope/SM\ntrophic\ntrophy/MGDS\ntropic/MS\ntropical/SY\ntropism/SM\ntropocollagen\ntroposphere/MS\ntropospheric\ntrot/S\ntroth/GDM\ntroths\ntrotted\ntrotter/SM\ntrotting\ntroubadour/SM\ntrouble/GDRSM\ntroubled/U\ntroublemaker/MS\ntroubler/M\ntroubleshoot/SRDZG\ntroubleshooter/M\ntroubleshot\ntroublesome/YP\ntroublesomeness/M\ntrough/M\ntroughs\ntrounce/GZDRS\ntrouncer/M\ntroupe/MZGSRD\ntrouper/M\ntrouser/DMGS\ntrousseau/M\ntrousseaux\ntrout/SM\ntrove/SM\ntrow/SGD\ntrowel/SMDRGZ\ntroweler/M\ntroy/S\ntruancy/MS\ntruant/SMDG\ntruce/SDGM\ntruck/SZGMRDJ\ntrucker/M\ntrucking/M\ntruckle/GDS\ntruckload/MS\ntruculence/SM\ntruculent/Y\ntrudge/SRDG\ntrue/DRSPTG\ntruelove/MS\ntrueness/M\ntruer/U\ntruest/U\ntruffle/MS\ntruism/SM\ntruly/U\ntrump/DMSG\ntrumpery/SM\ntrumpet/MDRZGS\ntrumpeter/M\ntruncate/NGDSX\ntruncation/M\ntruncheon/MDSG\ntrundle/GZDSR\ntrundler/M\ntrunk/GSMD\ntrunnion/SM\ntruss/SRDG\ntrusser/M\ntrussing/M\ntrust/RDMSG\ntrusted/EU\ntrustee/MDS\ntrusteeing\ntrusteeship/SM\ntruster/M\ntrustful/EY\ntrustfulness/SM\ntrustiness/M\ntrusting/Y\ntrusts/E\ntrustworthier\ntrustworthiest\ntrustworthiness/MS\ntrustworthy/UP\ntrusty/PTMSR\ntruth/UM\ntruthful/UYP\ntruthfulness/US\ntruths/U\ntry/JGDRSZ\ntrying/Y\ntryout/MS\ntrypsin/M\ntryst/GDMS\nts\ntsarevich\ntsarina's\ntsarism/M\ntsarist\ntsetse/S\ntsp\ntsunami/MS\ntty/M\nttys\ntub/JMDRSZG\ntuba/SM\ntubae\ntubal\ntubbed\ntubbing\ntubby/TR\ntube/SM\ntubeless\ntuber/M\ntubercle/MS\ntubercular/S\ntuberculin/MS\ntuberculoses\ntuberculosis/M\ntuberculous\ntuberose/SM\ntuberous\ntubing/M\ntubular/Y\ntubule/SM\ntuck/GZSRD\ntucker/GDM\ntuft/GZSMRD\ntufter/M\ntufting/M\ntug/S\ntugboat/MS\ntugged\ntugging\ntuition/ISM\ntularemia/S\ntulip/SM\ntulle/SM\ntum\ntumble/ZGRSDJ\ntumbledown\ntumbler/M\ntumbleweed/MS\ntumbrel/SM\ntumescence/S\ntumescent\ntumid/Y\ntumidity/MS\ntummy/SM\ntumor/MDS\ntumorous\ntumult/SGMD\ntumultuous/PY\ntumultuousness/M\ntumulus/M\ntun/DRJZGBS\ntuna/SM\ntunable/P\ntunableness/M\ntundra/SM\ntune's\ntune/CSDG\ntuneful/YP\ntunefulness/MS\ntuneless/Y\ntuner/M\ntuneup/S\ntung\ntungstate/M\ntungsten/SM\ntunic/MS\ntuning's\ntuning/A\ntunned\ntunnel/MRDSJGZ\ntunneler/M\ntunning\ntunny/SM\ntupelo/M\ntuple/SM\ntuppence/M\nturban/SDM\nturbid\nturbidity/SM\nturbinate/SD\nturbine/SM\nturbo/SM\nturbocharged\nturbocharger/SM\nturbofan/MS\nturbojet/MS\nturboprop/MS\nturbot/MS\nturbulence/SM\nturbulent/Y\nturd/MS\ntureen/MS\nturf/DGSM\nturfy/RT\nturgid/PY\nturgidity/SM\nturgidness/M\nturk/S\nturkey/SM\nturmeric/MS\nturmoil/SDMG\nturn/AZGRDBS\nturnabout/SM\nturnaround/MS\nturnbuckle/SM\nturncoat/SM\nturned/U\nturner/M\nturning/MS\nturnip/SMDG\nturnkey/MS\nturnoff/MS\nturnout/MS\nturnover/SM\nturnpike/MS\nturnround/MS\nturnstile/SM\nturnstone/M\nturntable/SM\nturpentine/GMSD\nturpitude/SM\nturquoise/SM\nturret/SMD\nturtle/SDMG\nturtleback/MS\nturtledove/MS\nturtleneck/SDM\nturves's\nturvy\ntush/SDG\ntusk/GZRDMS\ntusker/M\ntussle/GSD\ntussock/MS\ntussocky\ntut/S\ntutelage/MS\ntutelary/S\ntutor/MDGS\ntutored/U\ntutorial/MS\ntutorship/S\ntutted\ntutti/S\ntutting\ntutu/SM\ntux/S\ntuxedo/SDM\ntwaddle/GZMRSD\ntwaddler/M\ntwain/S\ntwang/MDSG\ntwangy/TR\ntwas\ntweak/SGRD\ntwee/DP\ntweed/SM\ntweediness/M\ntweedy/PTR\ntween\ntweet/ZSGRD\ntweeter/M\ntweeze/ZGRD\ntweezer/M\ntwelfth\ntwelfths\ntwelve/MS\ntwelvemonth/M\ntwelvemonths\ntwentieths\ntwenty/MSH\ntwerp/MS\ntwice/R\ntwiddle/GRSD\ntwiddler/M\ntwiddly/RT\ntwig/SM\ntwigged\ntwigging\ntwiggy/RT\ntwilight/MS\ntwilit\ntwill/SGD\ntwin/RDMGZS\ntwine/SM\ntwiner/M\ntwinge/SDMG\ntwinkle/RSDG\ntwinkler/M\ntwinkling/M\ntwinkly\ntwinned\ntwinning\ntwirl/SZGRD\ntwirler/M\ntwirling/Y\ntwirly/TR\ntwist/SZGRD\ntwisted/U\ntwister/M\ntwists/U\ntwisty\ntwit/S\ntwitch/GRSD\ntwitchy/TR\ntwitted\ntwitter/SGRD\ntwitterer/M\ntwittery\ntwitting\ntwixt\ntwo/MS\ntwofer/MS\ntwofold/S\ntwopence/SM\ntwopenny/S\ntwosome/MS\ntwp\ntycoon/MS\ntyeing\ntying/UA\ntyke/SM\ntympani\ntympanist/SM\ntympanum/SM\ntype/MGDRSJ\ntypeahead\ntypecast/SG\ntyped/AU\ntypedef/S\ntypeface/MS\ntypeless\ntypes/A\ntypescript/SM\ntypeset/S\ntypesetter/MS\ntypesetting/SM\ntypewrite/SRJZG\ntypewriter/M\ntypewriting/M\ntypewritten\ntypewrote\ntyphoid/SM\ntyphoon/SM\ntyphus/SM\ntypical/U\ntypicality/MS\ntypically\ntypicalness/M\ntypification/M\ntypify/SDNXG\ntyping/A\ntypist/MS\ntypo/MS\ntypographer/SM\ntypographic\ntypographical/Y\ntypography/MS\ntypological/Y\ntypology/MS\ntyrannic\ntyrannical/PY\ntyrannicalness/M\ntyrannicide/M\ntyrannize/ZGJRSD\ntyrannizer/M\ntyrannizing/YM\ntyrannosaur/MS\ntyrannosaurus/S\ntyrannous\ntyranny/MS\ntyrant/MS\ntyreo\ntyro/SM\ntyrosine/M\ntzar's\ntzarina's\nu\nubiquitous/YP\nubiquity/S\nudder/SM\nufologist/S\nufology/MS\nugh\nughs\nuglification\nugliness/MS\nuglis\nugly/PTGSRD\nuh\nukase/SM\nukulele/SM\nulcer/MDGS\nulcerate/NGVXDS\nulceration/M\nulcerous\nulna/M\nulnae\nulnar\nulster/MS\nult\nulterior/Y\nultimas\nultimate/DSYPG\nultimateness/M\nultimatum/MS\nultimo\nultra/S\nultracentrifugally\nultracentrifugation\nultracentrifuge/M\nultraconservative/S\nultrafast\nultrahigh\nultralight/S\nultramarine/SM\nultramodern\nultramontane\nultrashort\nultrasonic/S\nultrasonically\nultrasonics/M\nultrasound/SM\nultrastructure/M\nultraviolet/SM\nululate/DSXGN\nululation/M\num\numbel/MS\number/GMDS\numbilical/S\numbilici\numbilicus/M\numbra/MS\numbrage/MGSD\numbrageous\numbrella/GDMS\numiak/MS\numlaut/GMDS\nump/MDSG\numpire/MGSD\numpteen/H\nunabated/Y\nunabridged/S\nunacceptability\nunacceptable\nunaccepted\nunaccommodating\nunaccountability\nunaccustomed/Y\nunadapted\nunadulterated/Y\nunadventurous\nunalienability\nunalterable/P\nunalterableness/M\nunalterably\nunambiguity\nunambiguous\nunambitious\nunamused\nunanimity/SM\nunanimous/Y\nunanticipated/Y\nunapologetic\nunapologizing/M\nunappeasable\nunappeasably\nunappreciative\nunary\nunassailable/P\nunassailableness/M\nunassertive\nunassuming/PY\nunassumingness/M\nunauthorized/PY\nunavailing/PY\nunaware/SPY\nunbalanced/P\nunbar\nunbarring\nunbecoming/P\nunbeknown\nunbelieving/Y\nunbiased/P\nunbid\nunbind/G\nunblessed\nunblinking/Y\nunbodied\nunbolt/G\nunbreakability\nunbred\nunbroken\nunbuckle\nunbudging/Y\nunburnt\nuncap\nuncapping\nuncatalogued\nuncauterized/MS\nunceasing/Y\nuncelebrated\nuncertain/P\nunchallengeable\nunchanging/PY\nunchangingness/M\nuncharacteristic\nuncharismatic\nunchastity\nunchristian\nuncial/S\nuncivilized/Y\nunclassified\nuncle/MSD\nunclouded/Y\nuncodable\nuncollected\nuncolored/PY\nuncoloredness/M\nuncombable\nuncommunicative\nuncompetitive\nuncomplicated\nuncomprehending/Y\nuncompromisable\nunconcern/M\nunconcerned/P\nunconfirmed\nunconfused\nunconscionable/P\nunconscionableness/M\nunconscionably\nunconstitutional\nunconsumed\nuncontentious\nuncontrollability\nunconvertible\nuncool\nuncooperative\nuncork/G\nuncouple/G\nuncouth/YP\nuncouthness/M\nuncreate/V\nuncritical\nuncross/GB\nuncrowded\nunction/IM\nunctions\nunctuous/PY\nunctuousness/MS\nuncustomary\nuncut\nundated/I\nundaunted/Y\nundeceive\nundecided/S\nundedicated\nundefinability\nundefined/P\nundefinedness/M\nundelete\nundeliverability\nundeniable/P\nundeniableness/M\nundeniably\nundependable\nunder/Y\nunderachieve/SRDGZ\nunderachiever/M\nunderact/GDS\nunderadjusting\nunderage/S\nunderarm/DGS\nunderbedding\nunderbelly/MS\nunderbid/S\nunderbidding\nunderbracing\nunderbrush/MSDG\nundercarriage/MS\nundercharge/GSD\nunderclass/S\nunderclassman\nunderclassmen\nunderclothes\nunderclothing/MS\nundercoat/JMDGS\nundercoating/M\nunderconsumption/M\nundercooked\nundercount/S\nundercover\nundercurrent/SM\nundercut/S\nundercutting\nunderdeveloped\nunderdevelopment/MS\nunderdog/MS\nunderdone\nundereducated\nunderemphasis\nunderemployed\nunderemployment/SM\nunderenumerated\nunderenumeration\nunderestimate/NGXSD\nunderexploited\nunderexpose/SDG\nunderexposure/SM\nunderfed\nunderfeed/SG\nunderfloor\nunderflow/GDMS\nunderfoot\nunderfund/DG\nunderfur/MS\nundergarment/SM\nundergirding\nundergo/G\nundergoes\nundergone\nundergrad/MS\nundergraduate/MS\nunderground/RMS\nundergrowth/M\nundergrowths\nunderhand/D\nunderhanded/YP\nunderhandedness/MS\nunderheat\nunderinvestment\nunderlaid\nunderlain/S\nunderlay/GS\nunderlie\nunderline/GSDJ\nunderling/MS\nunderlip/SM\nunderloaded\nunderly/GS\nundermanned\nundermentioned\nundermine/SDG\nundermost\nunderneath\nunderneaths\nundernourished\nundernourishment/SM\nunderpaid\nunderpants\nunderpart/MS\nunderpass/SM\nunderpay/GSL\nunderpayment/SM\nunderperformed\nunderpin/S\nunderpinned\nunderpinning/MS\nunderplay/SGD\nunderpopulated\nunderpopulation/M\nunderpowered\nunderpricing\nunderprivileged\nunderproduction/MS\nunderrate/GSD\nunderregistration/M\nunderreported\nunderreporting\nunderrepresentation/M\nunderrepresented\nunderscore/SDG\nundersea/S\nundersealed\nundersecretary/SM\nundersell/SG\nundersexed\nundershirt/SM\nundershoot/SG\nundershorts\nundershot\nunderside/SM\nundersign/SGD\nundersigned/M\nundersized\nundersizes\nundersizing\nunderskirt/MS\nundersold\nunderspecification\nunderspecified\nunderspend/G\nunderstaffed\nunderstand/RGSJB\nunderstandability/M\nunderstandably\nunderstanding/YM\nunderstate/GSDL\nunderstatement/MS\nunderstocked\nunderstood\nunderstrength\nunderstructure/SM\nunderstudy/GMSD\nundertake/SRGZJ\nundertaken\nundertaker/M\nundertaking/M\nunderthings\nundertone/SM\nundertook\nundertow/MS\nunderused\nunderusing\nunderutilization/M\nunderutilized\nundervaluation/S\nundervalue/SDG\nunderwater/S\nunderway\nunderwear/M\nunderweight/S\nunderwent\nunderwhelm/DGS\nunderwood/M\nunderworld/MS\nunderwrite/GZSR\nunderwriter/M\nunderwritten\nunderwrote\nundeserving\nundesigned\nundeviating/Y\nundialyzed/SM\nundiplomatic\nundiscerning\nundiscriminating\nundo/GJ\nundoubted/Y\nundramatic\nundramatized/SM\nundress/G\nundrinkability\nundrinkable\nundroppable\nundue\nundulant\nundulate/XDSNG\nundulation/M\nunearth/YG\nunearthliness/S\nunearthly/P\nunease\nuneconomic\nuneducated\nunemployed/S\nunencroachable\nunending/Y\nunendurable/P\nunenergized/MS\nunenforced\nunenterprising\nunethical\nuneulogized/SM\nunexacting\nunexceptionably\nunexcited\nunexpectedness/MS\nunfading/Y\nunfailing/P\nunfailingness/M\nunfamiliar\nunfashionable\nunfathomably\nunfavored\nunfeeling\nunfeigned/Y\nunfelt\nunfeminine\nunfertile\nunfetchable\nunflagging\nunflappability/S\nunflappable\nunflappably\nunflinching/Y\nunfold/LG\nunfoldment/M\nunforced\nunforgeable\nunfossilized/MS\nunfraternizing/SM\nunfrozen\nunfulfillable\nunfunny\nunfussy\nungainliness/MS\nungainly/PRT\nungenerous\nungentle\nunglamorous\nungrammaticality\nungrudging\nunguent/MS\nungulate/MS\nunharmonious\nunharness/G\nunhistorical\nunholy/TP\nunhook/DG\nunhydrolyzed/SM\nunhygienic\nunicameral\nunicellular\nunicorn/SM\nunicycle/MGSD\nunicyclist/MS\nunideal\nunidimensional\nunidiomatic\nunidirectional/Y\nunidirectionality\nunidolized/MS\nunifiable\nunification/MA\nunifier/MS\nunifilar\nuniform/TGSRDYMP\nuniformity/MS\nuniformness/M\nunify/AXDSNG\nunilateral/Y\nunilateralism/M\nunilateralist\nunimodal\nunimpeachably\nunimportance\nunimportant\nunimpressive\nunindustrialized/MS\nuninhibited/YP\nuninominal\nuninsured\nunintellectual\nunintended\nuninteresting\nuninterrupted/YP\nuninterruptedness/M\nunintuitive\nuninviting\nunion/AEMS\nunionism/SM\nunionist/SM\nunionize\nunipolar\nuniprocessor/SM\nunique/TYSRP\nuniqueness/S\nunisex/S\nunison/MS\nunit/VGRD\nunitarian/MS\nunitarianism/M\nunitary\nunite/AEDSG\nunited/Y\nuniter/M\nunitize/GDS\nunity/SEM\nuniv\nunivalent/S\nunivalve/MS\nunivariate\nuniversal/YSP\nuniversalism/M\nuniversalistic\nuniversality/SM\nuniversalize/DSRZG\nuniversalizer/M\nuniverse/MS\nuniversity/MS\nunjam\nunkempt\nunkind/TP\nunkink\nunknightly\nunknowable/S\nunknowing\nunlabored\nunlace/G\nunlearn/G\nunlikeable\nunlikeliness/S\nunlimber/G\nunlimited\nunlit\nunliterary\nunloose/G\nunlucky/TP\nunmagnetized/MS\nunmanageably\nunmannered/Y\nunmask/G\nunmeaning\nunmeasured\nunmeetable\nunmelodious\nunmemorable\nunmemorialized/MS\nunmentionable/S\nunmerciful\nunmeritorious\nunmethodical\nunmineralized/MS\nunmissable\nunmistakably\nunmitigated/YP\nunmnemonic\nunmobilized/SM\nunmoral\nunmount/B\nunmovable\nunmoving\nunnaturalness/M\nunnavigable\nunnerving/Y\nunobliging\nunoffensive\nunofficial\nunorganized/YP\nunorthodox\nunpack/G\nunpaintable\nunpalatability\nunpalatable\nunpartizan\nunpatronizing\nunpeople\nunperceptive\nunperson\nunperturbed/Y\nunphysical\nunpick/G\nunpicturesque\nunpinning\nunpleasing\nunploughed\nunpolarized/SM\nunpopular\nunpractical\nunprecedented/Y\nunpredictable/S\nunpreemphasized\nunpremeditated\nunpretentiousness/M\nunprincipled/P\nunproblematic\nunproductive\nunpropitious\nunprovable\nunproven\nunprovocative\nunpunctual\nunquestionable\nunraisable\nunravellings\nunread/B\nunreadability\nunreal\nunrealizable\nunreasoning/Y\nunreceptive\nunrecordable\nunreflective\nunrelenting/Y\nunremitting/Y\nunrepeatability\nunrepeated\nunrepentant\nunreported\nunrepresentative\nunreproducible\nunrest/G\nunrestrained/P\nunrewarding\nunriddle\nunripe/P\nunromantic\nunruliness/SM\nunruly/PTR\nunsaleable\nunsanitary\nunsavored/YP\nunsavoriness/M\nunseal/GB\nunsearchable\nunseasonal\nunseeing/Y\nunseen/S\nunselfconscious/P\nunselfconsciousness/M\nunselfishness/M\nunsellable\nunsentimental\nunset\nunsettled/P\nunsettledness/M\nunsettling/Y\nunshapely\nunshaven\nunshorn\nunsighted\nunsightliness/S\nunskilful\nunsociability\nunsociable/P\nunsocial\nunsound/PT\nunspeakably\nunspecific\nunspectacular\nunspoilt\nunspoke\nunsporting\nunstable/P\nunstigmatized/SM\nunstilted\nunstinting/Y\nunstopping\nunstrapping\nunstudied\nunstuffy\nunsubdued\nunsubstantial\nunsubtle\nunsuitable\nunsuspecting/Y\nunswerving/Y\nunsymmetrical\nunsympathetic\nunsystematic\nunsystematized/Y\nuntactful\nuntalented\nuntaxing\nunteach/B\nuntellable\nuntenable\nunthinking\nuntil/G\nuntiring/Y\nunto\nuntouchable/MS\nuntoward/P\nuntowardness/M\nuntraceable\nuntrue\nuntruthfulness/M\nuntwist/G\nunusualness/M\nunutterable\nunutterably\nunvocalized/MS\nunvulcanized/SM\nunwaivering\nunwarrantable\nunwarrantably\nunwashed/PS\nunwearable\nunwearied/Y\nunwed\nunwedge\nunwelcome\nunwell/M\nunwieldiness/MS\nunwieldy/TPR\nunwind/B\nunwomanly\nunworkable/S\nunworried\nunwrap\nunwrapping\nunyielding/Y\nunyoke\nunzip\nup\nuparrow\nupbeat/SM\nupbraid/GDRS\nupbring/JG\nupbringing/M\nupchuck/SDG\nupcome/G\nupcountry/S\nupdatability\nupdate/RSDG\nupdater/M\nupdraft/SM\nupend/SDG\nupfield\nupfront\nupgrade/DSJG\nupgradeable\nupheaval/MS\nupheld\nuphill/S\nuphold/RSGZ\nupholder/M\nupholster/ADGS\nupholsterer/SM\nupholstery/MS\nupkeep/SM\nupland/MRS\nuplander/M\nuplift/SJDRG\nuplifter/M\nupload/GSD\nupmarket\nupon\nupped\nupper/S\nuppercase/GSD\nupperclassman/M\nupperclassmen\nuppercut/S\nuppercutting\nuppermost\nupping\nuppish\nuppity\nupraise/GDS\nuprated\nuprating\nuprear/DSG\nupright/DYGSP\nuprightness/S\nuprise/RGJ\nuprising/M\nupriver/S\nuproar/MS\nuproarious/PY\nuproariousness/M\nuproot/DRGS\nuprooter/M\nups\nupscale/GDS\nupset/S\nupsetting/MS\nupshot/SM\nupside/MS\nupsilon/MS\nupslope\nupstage/DSRG\nupstairs\nupstanding/P\nupstandingness/M\nupstart/MDGS\nupstate/SR\nupstream/DSG\nupstroke/MS\nupsurge/DSG\nupswing/GMS\nupswung\nuptake/SM\nupthrust/GMS\nuptight\nuptime\nuptown/RS\nuptrend/M\nupturn/GDS\nupward/SYP\nupwardness/M\nupwelling\nupwind/S\nuracil/MS\nuranium/MS\nuranyl/M\nurban/RT\nurbane/Y\nurbanism/M\nurbanite/SM\nurbanity/SM\nurbanization/MS\nurbanize/DSG\nurbanologist/S\nurbanology/S\nurchin/SM\nurea/SM\nuremia/MS\nuremic\nureter/MS\nurethane/MS\nurethra/M\nurethrae\nurethral\nurethritis/M\nurge/GDRSJ\nurgency/SM\nurgent/Y\nurger/M\nuric\nurinal/MS\nurinalyses\nurinalysis/M\nurinary/MS\nurinate/XDSNG\nurination/M\nurine/MS\nurn/MDGS\nurning/M\nurogenital\nurological\nurologist/S\nurology/MS\nursine\nurticaria/MS\nus/DRSBZG\nusability/S\nusable/U\nusably/U\nusage/SM\nuse/ESDAG\nused/U\nuseful/YP\nusefulness/SM\nuseless/PY\nuselessness/MS\nuser/M\nusher/SGMD\nusherette/SM\nusu\nusual/UPY\nusuals\nusurer/SM\nusurious/PY\nusuriousness/M\nusurp/RDZSG\nusurpation/MS\nusurper/M\nusury/SM\nutensil/SM\nuteri\nuterine\nuterus/M\nutile/I\nutilitarian/S\nutilitarianism/MS\nutility/MS\nutilization's/A\nutilization/MS\nutilize/GZDRS\nutilizer/M\nutilizes/A\nutmost/S\nutopia/S\nutopian's\nutopianism/M\nutter/TRDYGS\nutterance/MS\nuttered/U\nutterer/M\nuttermost/S\nuucp/M\nuvula/MS\nuvular/S\nuxorious\nv/ASV\nvacancy/MS\nvacant/PY\nvacantness/M\nvacate/NGXSD\nvacation/MRDZG\nvacationist/SM\nvacationland\nvaccinate/NGSDX\nvaccination/M\nvaccine/SM\nvaccinia/M\nvaccinial\nvacillate/XNGSD\nvacillating/Y\nvacillation/M\nvacillator/SM\nvacua's\nvacuity/MS\nvacuo\nvacuolate/SDGN\nvacuolated/U\nvacuole/SM\nvacuolization/SM\nvacuous/PY\nvacuousness/MS\nvacuum/GSMD\nvagabond/DMSG\nvagabondage/MS\nvagarious\nvagary/MS\nvagina/M\nvaginae\nvaginal/Y\nvagrancy/MS\nvagrant/SMY\nvague/TYSRDP\nvagueing\nvagueness/MS\nvain/TYRP\nvainglorious/YP\nvaingloriousness/M\nvainglory/MS\nval\nvalance/SDMG\nvale/SM\nvalediction/MS\nvaledictorian/MS\nvaledictory/MS\nvalence/SM\nvalency/MS\nvalentine/SM\nvalet/GDMS\nvaletudinarian/MS\nvaletudinarianism/MS\nvaliance/S\nvaliant/SPY\nvaliantness/M\nvalid/PIY\nvalidate/INGSDX\nvalidated/AU\nvalidates/A\nvalidation/AMI\nvalidity/IMS\nvalidness/MI\nvalidnesses\nvalise/MS\nvalley/SM\nvalor/MS\nvalorous/Y\nvaluable/IP\nvaluableness/IM\nvaluables\nvaluably/I\nvaluate/NGXSD\nvaluation/CSAM\nvaluator/SM\nvalue's\nvalue/CGASD\nvalued/U\nvalueless/P\nvaluelessness/M\nvaluer/SM\nvalues/E\nvalve/GMSD\nvalveless\nvalvular\nvamoose/GSD\nvamp's\nvamp/ADSG\nvamper\nvampire/MGSD\nvan/SMD\nvanadium/MS\nvandal/MS\nvandalism/MS\nvandalize/GSD\nvane/MS\nvanguard/MS\nvanilla/MS\nvanish/GRSDJ\nvanisher/M\nvanishing/Y\nvanity/SM\nvanned\nvanning\nvanquish/RSDGZ\nvanquisher/M\nvantage/MS\nvapid/PY\nvapidity/MS\nvapidness/SM\nvapor/MRDJGZS\nvaporer/M\nvaporing/MY\nvaporisation\nvaporise/DSG\nvaporization/AMS\nvaporize/DRSZG\nvaporizer/M\nvaporous\nvapory\nvaquero/SM\nvar/S\nvariability/IMS\nvariable/PMS\nvariableness/IM\nvariables/I\nvariably/I\nvariance's\nvariance/I\nvariances\nvariant/ISY\nvariate/MGNSDX\nvariation/M\nvariational\nvaricolored/MS\nvaricose/S\nvaried/U\nvariedly\nvariegate/NGXSD\nvariegation/M\nvarier/M\nvarietal/S\nvariety/MS\nvarious/PY\nvaristor/M\nvarlet/MS\nvarmint/SM\nvarnish/ZGMDRS\nvarnished/U\nvarnisher/M\nvarsity/MS\nvary/SRDJG\nvarying/UY\nvascular\nvase/SM\nvasectomy/SM\nvasomotor\nvassal/GSMD\nvassalage/MS\nvast/PTSYR\nvastness/MS\nvat/SM\nvatted\nvatting\nvaudeville/SM\nvaudevillian/SM\nvault/ZSRDMGJ\nvaulter/M\nvaulting/M\nvaunt/GRDS\nvaunter/M\nvb\nveal/MRDGS\nvealed/A\nvealer/MA\nveals/A\nvector's/F\nvector/SGDM\nvectorial\nvectorization\nvectorized\nvectorizing\nveejay/S\nveep/S\nveer/DSG\nveering/Y\nveg/M\nvegan/SM\nveges\nvegetable/MS\nvegetarian/SM\nvegetarianism/MS\nvegetate/DSNGVX\nvegetation/M\nvegetative/PY\nvegged\nveggie/S\nvegging\nvehemence/MS\nvehemency/S\nvehement/Y\nvehicle/SM\nvehicular\nveil's\nveil/UGSD\nveiling/MU\nvein/GSRDM\nveining/M\nvela/M\nvelar/S\nvelarize/SDG\nveld/SM\nveldt's\nvellum/MS\nvelocipede/SM\nvelocity/SM\nvelor/S\nvelour's\nvelum/M\nvelvet/GSMD\nvelveteen/MS\nvelvety/RT\nvenal/Y\nvenality/MS\nvenation/SM\nvend/DSG\nvender's/K\nvendetta/MS\nvendible/S\nvendor/MS\nveneer/GSRDM\nveneerer/M\nveneering/M\nvenerability/S\nvenerable/P\nvenerate/XNGSD\nveneration/M\nvenereal\nvenetian\nvengeance/MS\nvengeful/APY\nvengefulness/AM\nvenial/YP\nvenialness/M\nvenireman/M\nveniremen\nvenison/SM\nvenom/SGDM\nvenomous/YP\nvenomousness/M\nvenous/Y\nvent's/F\nvent/ISGFD\nventer/M\nventilate/XSDVGN\nventilated/U\nventilation/M\nventilator/MS\nventral/YS\nventricle/MS\nventricular\nventriloquies\nventriloquism/MS\nventriloquist/MS\nventriloquy\nventure/RSDJZG\nventuresome/YP\nventuresomeness/SM\nventuri/S\nventurous/YP\nventurousness/MS\nvenue/MAS\nveracious/YP\nveraciousness/M\nveracities\nveracity/IM\nveranda/SDM\nverandahed\nverb/KSM\nverbal/SY\nverbalization/MS\nverbalize/ZGRSD\nverbalized/U\nverbalizer/M\nverballed\nverballing\nverbatim\nverbena/MS\nverbiage/SM\nverbose/YP\nverbosity/SM\nverboten\nverdant/Y\nverdict/SM\nverdigris/GSDM\nverdure/SDM\nverge's\nverge/FGSD\nverger/SM\nveridical/Y\nverifiability/M\nverifiable/U\nverifiableness/M\nverification/S\nverified/U\nverifier/MS\nverify/GASD\nverily\nverisimilitude/SM\nveritable/P\nveritableness/M\nveritably\nverity/MS\nvermicelli/MS\nvermiculite/MS\nvermiform\nvermilion/MS\nvermin/M\nverminous\nvermouth/M\nvermouths\nvernacular/YS\nvernal/Y\nvernier/SM\nveronica/SM\nverruca/MS\nverrucae\nversa\nversatile/YP\nversatileness/M\nversatility/SM\nverse's\nverse/XSRDAGNF\nversed/UI\nverses/I\nversicle/M\nversification/M\nversifier/M\nversify/GDRSZXN\nversing/I\nversion/MFISA\nverso/SM\nversus\nvertebra/M\nvertebrae\nvertebral/Y\nvertebrate/IMS\nvertebration/M\nvertex/SM\nvertical/YPS\nvertices's\nvertiginous\nvertigo/M\nvertigoes\nverve/SM\nvery/RT\nvesicle/SM\nvesicular/Y\nvesiculate/GSD\nvesper/SM\nvessel/MS\nvest's\nvest/DIGSL\nvestal/YS\nvestibular\nvestibule/SDM\nvestige/SM\nvestigial/Y\nvesting/SM\nvestment/ISM\nvestry/MS\nvestryman/M\nvestrymen\nvesture/SDMG\nvet/SMR\nvetch/SM\nveter/M\nveteran/SM\nveterinarian/MS\nveterinary/S\nveto/DMG\nvetoes\nvetted\nvetting/A\nvex/GFSD\nvexation/SM\nvexatious/PY\nvexatiousness/M\nvexed/Y\nvhf\nvi/MDR\nvia\nviability/SM\nviable/I\nviably\nviaduct/MS\nvial/MDGS\nviand/SM\nvibe/S\nvibraharp/MS\nvibrancy/MS\nvibrant/YS\nvibraphone/MS\nvibraphonist/SM\nvibrate/XNGSD\nvibration/M\nvibrational/Y\nvibrato/MS\nvibrator/SM\nvibratory\nvibrio/M\nvibrionic\nviburnum/SM\nvicar/SM\nvicarage/SM\nvicarious/YP\nvicariousness/MS\nvice/CMS\nviced\nvicegerent/MS\nvicennial\nviceregal\nviceroy/SM\nvichyssoise/MS\nvicing\nvicinity/MS\nvicious/YP\nviciousness/S\nvicissitude/MS\nvictim/SM\nvictimization/SM\nvictimize/SRDZG\nvictimized/U\nvictimizer/M\nvictor/SM\nvictorious/YP\nvictoriousness/M\nvictory/MS\nvictual/ZGSDR\nvictualer/M\nvicua/S\nvidelicet\nvideo/GSMD\nvideocassette/S\nvideoconferencing\nvideodisc/S\nvideodisk/SM\nvideophone/SM\nvideotape/SDGM\nvie/S\nvier/M\nview/MBGZJSRD\nviewed/A\nviewer's\nviewer/AS\nviewfinder/MS\nviewgraph/SM\nviewing/M\nviewless/Y\nviewpoint/SM\nviews/A\nvigesimal\nvigil/SM\nvigilance/MS\nvigilant/Y\nvigilante/SM\nvigilantism/MS\nvigilantist\nvignette/MGDRS\nvignetter/M\nvignetting/M\nvignettist/MS\nvigor/MS\nvigorous/YP\nvigorousness/M\nvii\nviii\nviking/S\nvile/AR\nvilely\nvileness/MS\nvilest\nvilification/M\nvilifier/M\nvilify/GNXRSD\nvilla/MS\nvillage/RSMZ\nvillager/M\nvillain/SM\nvillainous/YP\nvillainousness/M\nvillainy/MS\nville\nvillein/MS\nvilleinage/SM\nvilli\nvillus/M\nvim/MS\nvinaigrette/MS\nvincible/I\nvindicate/XSDVGN\nvindication/M\nvindicator/SM\nvindictive/PY\nvindictiveness/MS\nvine/MGDS\nvinegar/DMSG\nvinegary\nvineyard/SM\nvino/MS\nvinous\nvintage/MRSDG\nvintager/M\nvintner/MS\nvinyl/SM\nviol/MSB\nviola/SM\nviolable/I\nviolate/VNGXSD\nviolator/MS\nviolence/SM\nviolent/Y\nviolet/SM\nviolin/MS\nviolinist/SM\nviolist/MS\nvioloncellist/S\nvioloncello/MS\nviper/MS\nviperous\nvirago/M\nviragoes\nviral/Y\nvireo/SM\nvirgin/SM\nvirginal/YS\nvirginity/SM\nvirgule/MS\nvirile\nvirility/MS\nvirologist/S\nvirology/SM\nvirtual/Y\nvirtue/SM\nvirtuosity/MS\nvirtuoso/MS\nvirtuosoes\nvirtuous/PY\nvirtuousness/SM\nvirulence/SM\nvirulent/Y\nvirus/MS\nvis/MDSGV\nvisa/SGMD\nvisage/MSD\nviscera\nvisceral/Y\nviscid/Y\nviscoelastic\nviscoelasticity\nviscometer/SM\nviscose/MS\nviscosity/MS\nviscount/MS\nviscountcy/MS\nviscountess/SM\nviscous/PY\nviscousness/M\nviscus/M\nvise's\nvise/CAXNGSD\nviselike\nvisibility/ISM\nvisible/PI\nvisibly/I\nvision's/A\nvision/KMDGS\nvisionariness/M\nvisionary/PS\nvisit/GASD\nvisitable/U\nvisitant/SM\nvisitation/SM\nvisited/U\nvisitor/MS\nvisor/SMDG\nvista/GSDM\nvisual/SY\nvisualization/AMS\nvisualize/SRDZG\nvisualized/U\nvisualizer/M\nvisualizes/A\nvita/M\nvitae\nvital/SY\nvitality/MS\nvitalization/AMS\nvitalize/ASDGC\nvitamin/SM\nvitiate/XGNSD\nvitiation/M\nviticulture/SM\nviticulturist/S\nvitreous/YSP\nvitrifaction/S\nvitrification/M\nvitrify/XDSNG\nvitrine/SM\nvitriol/MDSG\nvitriolic\nvitro\nvittles\nvituperate/SDXVGN\nvituperation/M\nvituperative/Y\nviva/DGS\nvivace/S\nvivacious/YP\nvivaciousness/MS\nvivacity/SM\nvivaria\nvivarium/MS\nvivaxes\nvive/Z\nvivid/PTYR\nvividness/SM\nvivifier\nvivify/NGASD\nviviparous\nvivisect/DGS\nvivisection/MS\nvivisectional\nvivisectionist/SM\nvivo\nvixen/SM\nvixenish/Y\nviz\nvizier/MS\nvizor's\nvocab/S\nvocable/SM\nvocabularian\nvocabularianism\nvocabulary/MS\nvocal/SY\nvocalic/S\nvocalise's\nvocalism/M\nvocalist/MS\nvocalization/SM\nvocalize/ZGDRS\nvocalized/U\nvocalizer/M\nvocation/AKMISF\nvocational/Y\nvocative/KYS\nvociferate/NGXSD\nvociferation/M\nvociferous/YP\nvociferousness/MS\nvocoded\nvocoder\nvodka/MS\nvoe/S\nvogue/GMSRD\nvogueing\nvoguish\nvoice/IMGDS\nvoiceband\nvoiced/CU\nvoiceless/YP\nvoicelessness/SM\nvoicer/S\nvoices/C\nvoicing/C\nvoid/C\nvoidable\nvoided\nvoider/M\nvoiding\nvoidness/M\nvoids\nvoile/MS\nvoil\nvol/GSD\nvolar\nvolatile/PS\nvolatileness/M\nvolatility/MS\nvolatilization/MS\nvolatilize/SDG\nvolcanic/S\nvolcanically\nvolcanism/M\nvolcano/M\nvolcanoes\nvole/MS\nvolition/MS\nvolitional/Y\nvolitionality\nvolley/SMRDG\nvolleyball/MS\nvolleyer/M\nvolt/AMS\nvoltage/SM\nvoltaic\nvoltmeter/MS\nvolubility/S\nvoluble/P\nvolubly\nvolume/SDGM\nvolumetric\nvolumetrically\nvoluminous/PY\nvoluminousness/MS\nvoluntarily/I\nvoluntariness/MI\nvoluntarism/MS\nvoluntary/PS\nvolunteer/DMSG\nvoluptuary/SM\nvoluptuous/YP\nvoluptuousness/S\nvolute/S\nvomit/GRDS\nvoodoo/GDMS\nvoodooism/S\nvoracious/YP\nvoraciousness/MS\nvoracity/MS\nvortex/SM\nvortices's\nvorticity/M\nvotary/MS\nvote's\nvote/CSDG\nvoter/SM\nvotive/YP\nvouch/SRDGZ\nvoucher/GMD\nvouchsafe/SDG\nvow/SMDRG\nvowel/MS\nvowelled\nvowelling\nvower/M\nvoyage/GMZJSRD\nvoyager/M\nvoyageur/SM\nvoyeur/MS\nvoyeurism/MS\nvoyeuristic\nvs\nvulcanization/SM\nvulcanize/SDG\nvulcanized/U\nvulgar/TSYR\nvulgarian/MS\nvulgarism/MS\nvulgarity/MS\nvulgarization/S\nvulgarize/GZSRD\nvulnerability/SI\nvulnerable/IP\nvulnerably/I\nvulpine\nvulture/SM\nvulturelike\nvulturous\nvulva/M\nvulvae\nvying\nw/XTJGV\nwackes\nwackiness/MS\nwacko/MS\nwacky/RTP\nwad/MDRZGS\nwadded\nwadding/SM\nwaddle/GRSD\nwade/S\nwader/M\nwadi/SM\nwafer/GSMD\nwaffle/GMZRSD\nwaft/SGRD\nwafter/M\nwag/DRZGS\nwage/SM\nwaged/U\nwager/GZMRD\nwagged\nwaggery/MS\nwagging\nwaggish/YP\nwaggishness/SM\nwaggle/SDG\nwaggly\nwagon/SGZMRD\nwagoner/M\nwagtail/SM\nwaif/SGDM\nwail/SGZRD\nwailer/M\nwain/GSDM\nwainscot/SGJD\nwainwright/SM\nwaist/GSRDM\nwaistband/MS\nwaistcoat/GDMS\nwaister/M\nwaistline/MS\nwait/GSZJRD\nwaiter/DMG\nwaitpeople\nwaitperson/S\nwaitress/GMSD\nwaive/SRDGZ\nwaiver/MB\nwake/MGDRSJ\nwakeful/PY\nwakefulness/MS\nwaken/SMRDG\nwaker/M\nwakeup\nwale/DRSMG\nwaling/M\nwalk/GZSBJRD\nwalkabout/M\nwalkaway/SM\nwalker/M\nwalkie\nwalkout/SM\nwalkover/SM\nwalkway/MS\nwall/SGMRD\nwallaby/MS\nwallah/M\nwallboard/MS\nwallet/SM\nwalleye/MSD\nwallflower/MS\nwallop/RDSJG\nwalloper/M\nwalloping/M\nwallow/RDSG\nwallower/M\nwallpaper/DMGS\nwally/S\nwalnut/SM\nwalrus/SM\nwaltz/MRSDGZ\nwaltzer/M\nwampum/SM\nwan/PGSDY\nwand/MRSZ\nwander/JZGRD\nwanderer/M\nwanderlust/SM\nwane/S\nwangle/RSDGZ\nwangler/M\nwanna\nwannabe/S\nwanned\nwanner\nwanness/S\nwannest\nwanning\nwant/GRDSJ\nwanted/U\nwanter/M\nwanton/PGSRDY\nwantonness/S\nwapiti/MS\nwar/GSMD\nwarble/GZRSD\nwarbler/M\nwarbonnet/S\nward/AGMRDS\nwarden/DMGS\nwarder/DMGS\nwardrobe/MDSG\nwardroom/MS\nwards/I\nwardship/M\nware/MS\nwarehouse/MGSRD\nwarehouseman/M\nwarfare/SM\nwarhead/MS\nwarhorse/SM\nwarily/U\nwariness/MS\nwarinesses/U\nwarless\nwarlike\nwarlock/SM\nwarlord/MS\nwarm/YRDHPGZTS\nwarmblooded\nwarmed/A\nwarmer/M\nwarmhearted/PY\nwarmheartedness/SM\nwarmish\nwarmness/MS\nwarmonger/JGSM\nwarmongering/M\nwarms/A\nwarmth/M\nwarmths\nwarn/GRDJS\nwarned/U\nwarner/M\nwarning/YM\nwarp/MRDGS\nwarpaint\nwarpath/M\nwarpaths\nwarper/M\nwarplane/MS\nwarrant/GSMDR\nwarranted/U\nwarranter/M\nwarranty/SDGM\nwarred/M\nwarren/SZRM\nwarrener/M\nwarring/M\nwarrior/MS\nwars/C\nwarship/MS\nwart/MDS\nwarthog/S\nwartime/SM\nwarty/RT\nwary/URPT\nwas/S\nwash/AGSD\nwashable/S\nwashbasin/SM\nwashboard/SM\nwashbowl/SM\nwashcloth/M\nwashcloths\nwashday/M\nwashed/U\nwasher/GDMS\nwasherwoman/M\nwasherwomen\nwashing/SM\nwashout/SM\nwashrag/SM\nwashroom/MS\nwashstand/SM\nwashtub/MS\nwashy/RT\nwasn't\nwasp/SM\nwaspish/PY\nwaspishness/SM\nwassail/GMDS\nwast/GZSRD\nwastage/SM\nwaste/S\nwastebasket/SM\nwasteful/YP\nwastefulness/S\nwasteland/MS\nwastepaper/MS\nwaster/DG\nwastewater\nwasting/Y\nwastrel/MS\nwatch/JRSDGZB\nwatchable/U\nwatchband/SM\nwatchdog/SM\nwatchdogged\nwatchdogging\nwatched/U\nwatcher/M\nwatchful/PY\nwatchfulness/MS\nwatchmake/JRGZ\nwatchmaker/M\nwatchman/M\nwatchmen\nwatchpoints\nwatchtower/MS\nwatchword/MS\nwater/JGSMRD\nwaterbird/S\nwaterborne\nwatercolor/DMGS\nwatercolorist/SM\nwatercourse/SM\nwatercraft/M\nwatercress/SM\nwaterer/M\nwaterfall/SM\nwaterfowl/M\nwaterfront/SM\nwaterhole/S\nwateriness/SM\nwatering/M\nwaterless\nwaterlily/S\nwaterline/S\nwaterlogged\nwaterloo\nwaterman/M\nwatermark/GSDM\nwatermelon/SM\nwatermill/S\nwaterproof/PGRDSJ\nwatershed/SM\nwaterside/MSR\nwatersider/M\nwaterspout/MS\nwatertight/P\nwatertightness/M\nwaterway/MS\nwaterwheel/S\nwaterworks/M\nwatery/PRT\nwatt/TMRS\nwattage/SM\nwattle/SDGM\nwave/ZGDRS\nwaveband/MS\nwaveform/SM\nwavefront/MS\nwaveguide/MS\nwavelength/M\nwavelengths\nwavelet/SM\nwavelike\nwavenumber\nwaver/GZRD\nwavering/YU\nwavily\nwaviness/MS\nwavy/SRTP\nwax/MNDRSZG\nwaxer/M\nwaxiness/MS\nwaxwing/MS\nwaxwork/MS\nwaxy/PRT\nway/MS\nwayfarer/MS\nwayfaring/S\nwaylaid\nwaylay/GRSZ\nwaylayer/M\nwayleave/MS\nwaymarked\nwayside/MS\nwayward/YP\nwaywardness/S\nwe\nwe'd\nwe'll\nwe're\nwe've\nweak/TXPYRN\nweaken/ZGRD\nweakener/M\nweakfish/SM\nweakish\nweakliness/M\nweakling/SM\nweakly/RTP\nweakness/MS\nweal/MHS\nwealth/M\nwealthiness/MS\nwealths\nwealthy/PTR\nwean/RDGS\nweaner/M\nweanling/M\nweapon/GDMS\nweaponless\nweaponry/MS\nwear/RBSJGZ\nwearable/S\nwearer/M\nwearied/U\nwearily\nweariness/MS\nwearing/Y\nwearisome/YP\nwearisomeness/M\nweary/TGPRSD\nwearying/Y\nweasel/SGMDY\nweather/MDRYJGS\nweatherbeaten\nweathercock/SDMG\nweatherer/M\nweathering/M\nweatherize/GSD\nweatherman/M\nweathermen\nweatherperson/S\nweatherproof/SGPD\nweatherstrip/S\nweatherstripped\nweatherstripping/S\nweave/SRDGZ\nweaver/M\nweaves/A\nweaving/A\nweb/SMR\nwebbed\nwebbing/MS\nweber/M\nwebfeet\nwebfoot/M\nwebsite/S\nwed/SA\nwedded/A\nwedder\nwedding/SM\nwedge/SDGM\nwedgie/RST\nwedlock/SM\nwee/DRST\nweed/SGMRDZ\nweeder/M\nweediness/M\nweedkiller/M\nweedless\nweedy/TRP\nweeing\nweek/SYM\nweekday/MS\nweekend/SDRMG\nweekender/M\nweekly/S\nweeknight/SM\nween/SGD\nweenie/M\nweeny/RSMT\nweep/SGZJRD\nweeper/M\nweepy/RST\nweevil/MS\nweft/SGMD\nweigh/RDJG\nweighed/UA\nweigher/M\nweighs/A\nweight/JMSRDG\nweighted/U\nweighter/M\nweightily\nweightiness/SM\nweighting/M\nweightless/YP\nweightlessness/SM\nweightlifter/S\nweightlifting/MS\nweighty/TPR\nweir/SDMG\nweird/YRDPGTS\nweirdie/SM\nweirdness/MS\nweirdo/SM\nwelcome/PRSDYG\nwelcomeness/M\nwelcoming/U\nweld/SBJGZRD\nwelder/M\nwelfare/SM\nwelkin/SM\nwell/SGPD\nwellbeing/M\nwellhead/SM\nwellington/S\nwellness/MS\nwellspring/SM\nwelsh/RSDGZ\nwelsher/M\nwelt/GZSMRD\nwelter/GD\nwelterweight/MS\nwen/M\nwench/GRSDM\nwencher/M\nwend/DSG\nwent\nwept/U\nwere\nweren't\nwerewolf/M\nwerewolves\nwerwolf's\nwest/RDGSM\nwestbound\nwester/DYG\nwesterly/S\nwestern/ZSR\nwesterner/M\nwesternization/MS\nwesternize/GSD\nwesternmost\nwesting/M\nwestward/S\nwet/SPY\nwetback/MS\nwetland/S\nwetness/MS\nwettable\nwetter/S\nwettest\nwetting\nwhack/GZRDS\nwhacker/M\nwhale/GSRDZM\nwhaleboat/MS\nwhalebone/SM\nwhaler/M\nwhaling/M\nwham/MS\nwhammed\nwhamming/M\nwhammy/S\nwharf/SGMD\nwharves\nwhat'd\nwhat're\nwhat/MS\nwhatchamacallit/MS\nwhatever\nwhatnot/MS\nwhatsoever\nwheal/MS\nwheat/NMXS\nwheatgerm\nwhee/S\nwheedle/ZDRSG\nwheel/RDMJSGZ\nwheelbarrow/GSDM\nwheelbase/MS\nwheelchair/MS\nwheeler/M\nwheelhouse/SM\nwheelie/MS\nwheeling/M\nwheelwright/MS\nwheeze/SDG\nwheezily\nwheeziness/SM\nwheezy/PRT\nwhelk/MDS\nwhelm/DGS\nwhelp/DMGS\nwhen/S\nwhence/S\nwhenever\nwhensoever\nwhere'd\nwhere're\nwhere/MS\nwhereabout/S\nwhereas/S\nwhereat\nwhereby\nwherefore/MS\nwherein\nwhereof\nwhereon\nwheresoever\nwhereto\nwhereupon\nwherever\nwherewith\nwherewithal/SM\nwherry/DSGM\nwhet/S\nwhether\nwhetstone/MS\nwhetted\nwhetting\nwhew/GSD\nwhey/MS\nwhich\nwhichever\nwhiff/GSMD\nwhiffle/DRSG\nwhiffler/M\nwhiffletree/SM\nwhig/S\nwhile/GSD\nwhilom\nwhilst\nwhim/SM\nwhimmed\nwhimming\nwhimper/DSG\nwhimsey's\nwhimsical/YP\nwhimsicality/MS\nwhimsy/TMDRS\nwhine/GZMSRD\nwhining/Y\nwhinny/GTDRS\nwhiny/RT\nwhip/SM\nwhipcord/SM\nwhiplash/SDMG\nwhipped\nwhipper/MS\nwhippersnapper/MS\nwhippet/MS\nwhipping/SM\nwhippletree/SM\nwhippoorwill/SM\nwhips/M\nwhipsaw/GDMS\nwhir/SY\nwhirl/RDGS\nwhirligig/MS\nwhirlpool/MS\nwhirlwind/MS\nwhirly/MS\nwhirlybird/MS\nwhirred\nwhirring\nwhisk/GZRDS\nwhisker/DM\nwhiskery\nwhiskey/SM\nwhisper/GRDJZS\nwhisperer/M\nwhispering/YM\nwhist/GDMS\nwhistle/DRSZG\nwhistleable\nwhistler/M\nwhistling/M\nwhit/SJGTXMRND\nwhite/PYS\nwhitebait/M\nwhitecap/MS\nwhiteface/M\nwhitefish/SM\nwhitehead/S\nwhiten/JZDRG\nwhitener/M\nwhiteness/MS\nwhitening/M\nwhiteout/S\nwhitespace\nwhitetail/S\nwhitewall/SM\nwhitewash/GRSDM\nwhitewater\nwhitey/MS\nwhither/DGS\nwhitier\nwhitiest\nwhiting/M\nwhitish\nwhitter\nwhittle/JDRSZG\nwhittler/M\nwhiz\nwhizkid\nwhizzbang/S\nwhizzed\nwhizzes\nwhizzing\nwho'd\nwho'll\nwho're\nwho've\nwho/M\nwhoa/S\nwhodunit/SM\nwhoever\nwhole/SP\nwholegrain\nwholehearted/PY\nwholeheartedness/MS\nwholemeal\nwholeness/S\nwholesale/GZMSRD\nwholesaler/M\nwholesome/UYP\nwholesomeness/USM\nwholewheat\nwholly\nwhom\nwhomever\nwhomsoever\nwhoop/SRDGZ\nwhoopee/S\nwhooper/M\nwhoosh/DSGM\nwhop\nwhopper/MS\nwhopping/S\nwhore/SDGM\nwhorehouse/SM\nwhoreish\nwhorish\nwhorl/SDM\nwhose\nwhoso\nwhosoever\nwhy\nwhys\nwick/GZRDMS\nwicked/RYPT\nwickedness/MS\nwicker/M\nwickerwork/MS\nwicket/SM\nwicketkeeper/SM\nwicking/M\nwide/RSYTP\nwidemouthed\nwiden/SGZRD\nwidener/M\nwideness/S\nwidespread\nwidgeon's\nwidget/SM\nwidow/MRDSGZ\nwidower/M\nwidowhood/S\nwidth/M\nwidths\nwidthwise\nwield/GZRDS\nwielder/M\nwiener/SM\nwienie/SM\nwife/DSMYG\nwifeless\nwifely/RPT\nwig/MS\nwigeon/MS\nwigged\nwigging/M\nwiggle/RSDGZ\nwiggler/M\nwiggly/RT\nwight/SGDM\nwiglet/S\nwigmaker\nwigwag/S\nwigwagged\nwigwagging\nwigwam/MS\nwild/SPGTYRD\nwildcat/SM\nwildcatted\nwildcatter/MS\nwildcatting\nwildebeest/SM\nwilder/P\nwilderness/SM\nwildfire/MS\nwildflower/S\nwildfowl/M\nwilding/M\nwildlife/M\nwildness/MS\nwile/DSMG\nwilfulness's\nwilily\nwiliness/MS\nwill/SGJRD\nwilled/U\nwiller/M\nwillful/YP\nwillfulness/S\nwillies\nwilling/UYP\nwillinger\nwillingest\nwillingness's\nwillingness/US\nwilliwaw/MS\nwillow/RDMSG\nwillower/M\nwillowy/TR\nwillpower/MS\nwilt/DGS\nwily/PTR\nwimp/GSMD\nwimpish\nwimple/SDGM\nwimpy/RT\nwin/ZGDRS\nwince/SDG\nwinch/GRSDM\nwincher/M\nwinchester/M\nwind's\nwind/USRZG\nwindbag/SM\nwindblown\nwindbreak/MZSR\nwindburn/GSMD\nwinded\nwinder/UM\nwindfall/SM\nwindflower/MS\nwindily\nwindiness/SM\nwinding/MS\nwindjammer/SM\nwindlass/GMSD\nwindless/YP\nwindmill/GDMS\nwindow/DMGS\nwindowless\nwindowpane/SM\nwindowsill/SM\nwindpipe/SM\nwindproof\nwindrow/GDMS\nwinds/A\nwindscreen/MS\nwindshield/SM\nwindsock/MS\nwindstorm/MS\nwindsurf/GZJSRD\nwindswept\nwindup/MS\nwindward/SY\nwindy/TPR\nwine/MS\nwineglass/SM\nwinegrower/SM\nwinemake\nwinemaster\nwinery/MS\nwineskin/M\nwing/GZRDM\nwingback/M\nwingding/MS\nwingeing\nwinger/M\nwingless\nwinglike\nwingman\nwingmen\nwingspan/SM\nwingspread/MS\nwingtip/S\nwink/GZRDS\nwinker/M\nwinking/U\nwinkle/SDGM\nwinless\nwinnable\nwinner/MS\nwinning/SY\nwinnow/SZGRD\nwino/MS\nwinsome/PRTY\nwinsomeness/SM\nwinter/SGRDYM\nwinterer/M\nwintergreen/SM\nwinterize/GSD\nwintertime/MS\nwintriness/M\nwintry/TPR\nwiny/RT\nwipe/DRSZG\nwiper/M\nwire's\nwire/UDA\nwirehair/MS\nwireless/MSDG\nwireman/M\nwiremen\nwirer/M\nwires/A\nwiretap/MS\nwiretapped\nwiretapper/SM\nwiretapping\nwiriness/S\nwiring/SM\nwiry/RTP\nwisdom/UM\nwisdoms\nwise/URTY\nwiseacre/MS\nwisecrack/GMRDS\nwised\nwisely/TR\nwiseness\nwisenheimer/M\nwises\nwish/GZSRD\nwishbone/MS\nwishful/PY\nwishfulness/M\nwishy\nwising\nwisp/MDGS\nwispy/RT\nwist/DGS\nwisteria/SM\nwistful/PY\nwistfulness/MS\nwit/PSM\nwitch/SDMG\nwitchcraft/SM\nwitchdoctor/S\nwitchery/MS\nwith/GSRDZ\nwithal\nwithdraw/RGS\nwithdrawal/MS\nwithdrawer/M\nwithdrawn/P\nwithdrawnness/M\nwithdrew\nwithe/M\nwither/GDJ\nwithering/Y\nwithheld\nwithhold/SJGZR\nwithholder/M\nwithin/S\nwithout/S\nwiths\nwithstand/SG\nwithstood\nwitless/PY\nwitlessness/MS\nwitness/DSMG\nwitnessed/U\nwitted\nwitter/G\nwitticism/MS\nwittily\nwittiness/SM\nwitting/UY\nwittings\nwitty/RTP\nwive/GDS\nwives/M\nwiz's\nwizard/MYS\nwizardry/MS\nwizen/D\nwk/Y\nwoad/MS\nwobble/GSRD\nwobbler/M\nwobbliness/S\nwobbly/PRST\nwoe/PSM\nwoebegone/P\nwoeful/PY\nwoefuller\nwoefullest\nwoefulness/SM\nwok/SMN\nwoke\nwold/MS\nwolf/RDMGS\nwolfer/M\nwolfhound/MS\nwolfish/YP\nwolfishness/M\nwolfram/MS\nwolverine/SM\nwolves/M\nwoman/GSMYD\nwomanhood/MS\nwomanish\nwomanize/RSDZG\nwomanized/U\nwomanizer/M\nwomanizes/U\nwomankind/M\nwomanlike\nwomanliness/SM\nwomanly/PRT\nwomb/SDM\nwombat/MS\nwomen/MS\nwomenfolk/MS\nwon't\nwon/SG\nwonder/GLRDMS\nwonderer/M\nwonderful/PY\nwonderfulness/SM\nwondering/Y\nwonderland/SM\nwonderment/SM\nwondrous/YP\nwondrousness/M\nwonk/S\nwonky/RT\nwonned\nwonning\nwont/SGMD\nwonted/PUY\nwontedness/MU\nwoo/DRZGS\nwood/SMNDG\nwoodbine/SM\nwoodblock/S\nwoodcarver/S\nwoodcarving/MS\nwoodchopper/SM\nwoodchuck/MS\nwoodcock/MS\nwoodcraft/MS\nwoodcut/SM\nwoodcutter/MS\nwoodcutting/MS\nwooden/TPRY\nwoodenness/SM\nwoodgrain/G\nwoodhen\nwoodiness/MS\nwoodland/SRM\nwoodlice\nwoodlot/S\nwoodlouse/M\nwoodman/M\nwoodmen\nwoodpecker/SM\nwoodpile/SM\nwoodruff/M\nwoods/R\nwoodshed/SM\nwoodshedded\nwoodshedding\nwoodside\nwoodsman/M\nwoodsmen\nwoodsmoke\nwoodsy/TRP\nwoodwind/S\nwoodwork/SMRGZJ\nwoodworker/M\nwoodworking/M\nwoodworm/M\nwoody/TPSR\nwoodyard\nwoof/SRDMGZ\nwoofer/M\nwool/SMYNDX\nwoolgather/RGJ\nwoolgatherer/M\nwoolgathering/M\nwoolliness/MS\nwoolly/RSPT\nwoozily\nwooziness/MS\nwoozy/RTP\nwop/MS!\nword's\nword/AGSJD\nwordage/SM\nwordbook/MS\nwordily\nwordiness/SM\nwording/AM\nwordless/Y\nwordplay/SM\nwordy/TPR\nwore\nwork/GZJSRDMB\nworkability's\nworkability/U\nworkable/U\nworkableness/M\nworkably\nworkaday\nworkaholic/S\nworkaround/SM\nworkbench/MS\nworkbook/SM\nworkday/SM\nworked/A\nworker/M\nworkfare/S\nworkforce/S\nworkhorse/MS\nworkhouse/SM\nworking/M\nworkingman/M\nworkingmen\nworkingwoman/M\nworkingwomen\nworkload/SM\nworkman/MY\nworkmanlike\nworkmanship/MS\nworkmate/S\nworkmen/M\nworkout/SM\nworkpiece/SM\nworkplace/SM\nworkroom/MS\nworks/A\nworksheet/S\nworkshop/MS\nworkspace/S\nworkstation/MS\nworktable/SM\nworktop/S\nworkup/S\nworkweek/SM\nworld/ZSYM\nworldlier\nworldliest\nworldliness/USM\nworldly/UP\nworldwide\nworm/SGMRD\nwormer/M\nwormhole/SM\nwormwood/SM\nwormy/RT\nworn/U\nworried/Y\nworrier/M\nworriment/MS\nworrisome/YP\nworry/ZGSRD\nworrying/Y\nworrywart/SM\nworse/SR\nworsen/GSD\nworship/ZDRGS\nworshiper/M\nworshipful/YP\nworshipfulness/M\nworst/SGD\nworsted/MS\nwort/SM\nworth/DG\nworthily/U\nworthiness/SM\nworthinesses/U\nworthless/PY\nworthlessness/SM\nworths\nworthwhile/P\nworthy/UTSRP\nwost\nwot\nwould've\nwould/S\nwouldn't\nwouldst\nwound's\nwound/AU\nwounded/U\nwounder\nwounding\nwounds\nwove/A\nwoven/AU\nwovens\nwow/SDG\nwpm\nwrack/SGMD\nwraith/M\nwraiths\nwrangle/GZDRS\nwrangler/M\nwrap/MS\nwraparound/S\nwrapped/U\nwrapper/MS\nwrapping/SM\nwraps/U\nwrasse/SM\nwrath/GDM\nwrathful/YP\nwraths\nwreak/SDG\nwreath/GMDS\nwreathe\nwreaths\nwreck/GZRDS\nwreckage/MS\nwrecker/M\nwren/MS\nwrench/MDSG\nwrenching/Y\nwrest/SRDG\nwrester/M\nwrestle/JGZDRS\nwrestler/M\nwrestling/M\nwretch/MDS\nwretched/TPYR\nwretchedness/SM\nwriggle/DRSGZ\nwriggler/M\nwriggly/RT\nwright/MS\nwring/GZRS\nwringer/M\nwrinkle/GMDS\nwrinkled/U\nwrinkly/RST\nwrist/MS\nwristband/SM\nwristwatch/MS\nwrit/MRSBJGZ\nwritable/U\nwrite/ASBRJG\nwriter/MA\nwriteup\nwrithe/SDG\nwriting/M\nwritten/UA\nwrong/PSGTYRD\nwrongdoer/MS\nwrongdoing/MS\nwronger/M\nwrongful/PY\nwrongfulness/MS\nwrongheaded/PY\nwrongheadedness/MS\nwrongness/MS\nwrote/A\nwroth\nwrought/I\nwrung\nwry/DSGY\nwryer\nwryest\nwryness/SM\nwt\nwurst/SM\nwuss/S\nwussy/TRS\nx\nxenon/SM\nxenophobe/MS\nxenophobia/SM\nxenophobic\nxerographic\nxerography/MS\nxerox/GSD\nxi/M\nxii\nxiii\nxis\nxiv\nxix\nxterm/M\nxv\nxvi\nxvii\nxviii\nxx\nxylem/SM\nxylene/M\nxylophone/MS\nxylophonist/S\ny'all\ny/F\nya\nyacc/M\nyacht/ZGJSDM\nyachting/M\nyachtsman\nyachtsmen\nyachtswoman/M\nyachtswomen\nyack's\nyahoo/MS\nyak/SM\nyakked\nyakking\nyam/SM\nyammer/RDZGS\nyang/S\nyank/GDS\nyap/S\nyapped\nyapping\nyard/SMDG\nyardage/SM\nyardarm/SM\nyardman/M\nyardmaster/S\nyardmen\nyardstick/SM\nyarmulke/SM\nyarn/SGDM\nyarrow/MS\nyaw/DSG\nyawl/SGMD\nyawn/GZSDR\nyawner/M\nyawning/Y\nyd\nye/T\nyea/S\nyeah\nyeahs\nyear/YMS\nyearbook/SM\nyearling/M\nyearlong\nyearly/S\nyearn/JSGRD\nyearner/M\nyearning/MY\nyeast/SGDM\nyeastiness/M\nyeasty/PTR\nyecch\nyegg/MS\nyell/GSDR\nyellow/TGPSRDM\nyellowhammers\nyellowish\nyellowness/MS\nyellowy\nyelp/GSDR\nyelper/M\nyen/SM\nyenned\nyenning\nyeoman/YM\nyeomanry/MS\nyeomen\nyep/S\nyes/S\nyeshiva/SM\nyessed\nyessing\nyesterday/MS\nyesteryear/SM\nyet\nyeti/SM\nyew/SM\nyield/JGRDS\nyielded/U\nyielding/U\nyikes\nyin/S\nyip/S\nyipe/S\nyipped\nyippee/S\nyipping\nyo\nyodel/SZRDG\nyodeler/M\nyoga/MS\nyoghurt's\nyogi/MS\nyogurt/SM\nyoke/DSMG\nyoked/U\nyokel/SM\nyokes/U\nyoking/U\nyolk/DMS\nyon\nyonder\nyore/MS\nyorker/SM\nyou'd\nyou'll\nyou're\nyou've\nyou/SH\nyoung/TRYP\nyoungish\nyoungster/MS\nyour/MS\nyourself\nyourselves\nyouth/SM\nyouthful/YP\nyouthfulness/SM\nyouths\nyow\nyowl/GSD\nyr\nyrs\nytterbium/MS\nyttrium/SM\nyuan/M\nyucca/MS\nyuck/GSD\nyucky/RT\nyuk/S\nyukked\nyukking\nyule/MS\nyuletide/MS\nyum\nyummy/TRS\nyup/S\nyuppie/SM\nyurt/SM\nz/TGJ\nzag/S\nzagging\nzaniness/MS\nzany/PDSRTG\nzap/S\nzapped\nzapper/S\nzapping\nzeal/MS\nzealot/MS\nzealotry/MS\nzealous/YP\nzealousness/SM\nzebra/MS\nzebu/SM\nzed/SM\nzeitgeist/S\nzenith/M\nzeniths\nzephyr/MS\nzeppelin/SM\nzero/SDHMG\nzeroed/M\nzeroing/M\nzest/MDSG\nzestful/YP\nzestfulness/MS\nzesty/RT\nzeta/SM\nzeugma/M\nzig\nzigged\nzigging\nzigzag/MS\nzigzagged\nzigzagger\nzigzagging\nzilch/S\nzillion/MS\nzinc/MS\nzincked\nzincking\nzing/GZDRM\nzingy/RT\nzinnia/SM\nzip/MS\nzipped/U\nzipper/GSDM\nzipping/U\nzippy/RT\nzips/U\nzircon/SM\nzirconium/MS\nzit/S\nzither/SM\nzloty/SM\nzodiac/SM\nzodiacal\nzombi's\nzombie/SM\nzonal/Y\nzone/MYDSRJG\nzoned/A\nzones/A\nzoning/A\nzonked\nzoo/SM\nzookeepers\nzoological/Y\nzoologist/SM\nzoology/MS\nzoom/DGS\nzoophyte/SM\nzoophytic\nzounds/S\nzucchini/SM\nzwieback/MS\nzydeco/S\nzygote/SM\nzygotic\nzymurgy/S\nngstrm/M\nclair/MS\nclat/MS\nlan/M\nmigr/S\npe/S\ntude/MS\n"
  },
  {
    "path": "scripts/hunspell/isocpp.dic",
    "content": "'\n10'000\n0xFF0000\n0b0101'0101\n10x\n20x\n2D\n2K\n2ndEdition\n2RDU00001\n3rdEdition\n98's\nà\na1\na2\naa\nABA\nabi\nABIs\nAbrahams\nAbrahams01\nabstr\naccessor\nack\nACCU\naddressof\nADL\nAdve\nAlexandrescu\nAlexandrescu01\nalgo\nalloc\nalloc0\nap\nAPI\nAPIs\narchetypical\narg\nargh\nargs\narithmeticcast\narr2\narrayindex\nASIC\nasio\nAST\nasync\nAUTOSAR\n'B'\nb2\nBDE\nbehaviorless\nBigTrivial\nBigObject\nBjarne\nBloomberg\nBoehm\nbool\nbuf\nbufmax\nbY\nC1\nC11\nC2\ncallees\ncallers'\ncall's\nCamelCase\nCaMeLcAsEvArIaBlE\nCargill\nCargill92\ncbegin\nCComPtr\ncend\ncerr\ncharp\nchrono\ncin\nClang's\nclass'\nclib\nCline99\ncm3\nCommonMark\ncompleters\ncomponentization\ncomposability\ncomposable\nComputationCache\ncond\nconst\nconstcast\nconstexpr\nconstref\ncopy2\ncoro\nCORBA\ncout\nCP\ncplusplus\nCplusplus03\ncpp\nCppCon\nCppCoreCheck\ncppcoreguidelines\ncppreference\nCRTP\ncr\ncst\ncstdarg\ncstdio\ncstring\ncstylecast\nctor\nctors\ncxx\ncyclomatic\nczstring\nd1\nd2\nd2's\ndag\nDataRecord\ndcl\ndd\nde\nDechev\ndefault0\ndefault00\ndefop\ndel\nderef\nderived1\ndestructors\nDewhurst\nDewhurst03\ndisambiguator\ndraw2\ndtor\ndtors\ndyn\ndynarray\nECBS\nendl\nenum\nenums\neq\neqdefault\nEqualityComparable\nerrno\nexpr\nf1\nf2\nf3\nf4\nfac\nFacebook\nfallthrough\nfallthroughs\nfaq\nfclose\nfct\nfib10\nfile1\nfile2\nfile3\nfilesystem\nflag1\nfmt\nfn\nfo\nfoo\nfoobar\nfopen\nfprintf's\nfs\nfunc\nfunc1\nfx\ng2\nGCC\nGeosoft\ngetline\ngetx\nGFM\nGirou\ngithub\nGitHub\nGOTW\ngp\nGPLv3\ngrep\ngsl\nGSL's\ngx\nhandcoded\nHenricson\nHenricson97\nHerlihy\nhh\nhier\nhierclass\nhnd\nhomebrew\nHPL\nhref\nHyslop\ni2\nIDE\nidentitycast\nIDEs\nIEC\nifdef\nifstream\nimpactful\nimpl\nimplicitpointercast\nincform\nincrement1\nIncrementable\nindices\ning\ninit\ninline\ninlined\ninlining\ninout\nint32\nint64\nints\nio\nios\niostream\niostreams\niso\nisocpp\nISORC\nistream\nIter\nJiangang\njmp\nJSF\njthread\nJuhl\nknr\nknuth\nKoenig97\nLakos\nLakos96\nLavavej\nLCSD05\nlifecycle\nlinearization\nllvm\nlockfree\nLomow\nlongjmp\nLSP\nlst\nLuchangco\nlvalue\nlvalues\nm1\nm2\nm3\nmacros2\nmacros3\nmalloc\nmallocfree\nMathematizing\nmaul2\nmd\nmembers'\nmemcmp\nmemcpy\nmemmove\nmemoization\nmemoized\nmemoizes\nmemset\nmetameta\nmetaprogram\nmetaprograms\nmetaprogramming\nMeyers01\nMeyers05\nMeyers15\nMeyers96\nMeyers97\nmicrobenchmarks\nmiddleware\nMISRA\nmixin\nmixins\nmodify1\nmodify2\nmtx\nMurray93\nmutex\nmutexes\nmx\nmyMap\nMyMap\nmyX\nn'\nnaïvely\nnamespace\nnamespaces\nNaN\nnargs\nNaumann\nness\nnewdelete\nnh\nNir\nNL\nnodiscard\nnoexcept\nnoname\nnondependent\nnonprivate\nnothrow\nNR\nnullptr\nNVI\nofstream\nok\noo\nOOP\nOOPSLA'09\noper\noptimizable\nO'Reilly\norg\nostream\nostringstream\noverabstract\noverconstrain\noverconstrained\noverridable\noverriders\np1\np2\np3\nPardoe\nparens\npassthrough\npb\npb1\npb2\npc\nperformant\npessimization\npicture1\npimpl\nPirkelbauer\nPL4\nPLDI\nPoco\npoly\npolymorphically\nPOPL\nPortHandle\npp216\nPPP\npragma\npre\nprecomputation\nprefetcher\nprintf\nProc\nproductinfo\nproto\nps\nptr\nptrdiff\nptr2\nq2\nqqq\nqsort\nr0\nr2\nra\nraii\nrc\nrclib\nrcon\nrconc\nrconst\nrcoro\nrcpl\nRec2\nrefactor\nrefactored\nrefcount\nrefcounted\nregex\nRegularFunction\nreimplement\nreinterpretcast\nReis\nReis's\nrenum\nreseat\nreseating\nreseats\nresizable\nrethrow\nrethrowing\nretryable\n*Re-usability\nreusability\nrf\nrh\nri\nrio\nrl\nrnr\nro\nRouquette\nrp\nrper\nrr\nrsl\nrstr\nRTTI\nru\nrvalue\nrvalues\nRVO\n's\ns1\ns1's\ns2\ns3\nSarkar\nscanf\nsd\nSEI\nsemiregular\nSemiRegular\nSergey\nSewell\nShavit\nsharedFoo\nsharedness\nsharedptrparam\n'sharedptrparam'\nsetjmp\nSignedIntegral\nsignedness\n'size'\nsizeof\nsl\nsmartptrget\nsmartptrparam\nsmartptrs\nSMS\nSommerlad\nSomeLargeType\nspecialization2\nspinlock\nsplonk\nsplunk\nss\nsscp\nstdarg\nstdlib\nStepanov\nstl\nstmt\nstr\nstrdup\nstringification\nstrlen\nStr15\nStroustrup\nStroustrup00\nStroustrup05\nStroustrup13\nStroustrup14\nStroustrup15\nStroustrup94\nStroustrup's\nstruct\nstructs\nsubobject\nsubobjects\nsuboperations\nsubsetting\nsum1\nsum2\nsupertype\nSusmit\nSuttAlex05\nSutter\nSutter00\nSutter02\nSutter04\nSutter's\nSuttHysl04b\nsz\nt0\nTaligent94\nTaligent's\ntemplated\nTemplating\ntemplatize\ntemplatized\nthread1\nthread2\nTjark\ntmp\ntock\nTODO\ntolower\ntoolchains\nTotallyOrdered\nTP\ntradeoff\nTSAN\nTSs\ntt\ntypeid\ntypename\ntypesafe\nUB\nu1\nu2\nUDLs\nunaliased\nuncompromised\nuncopyable\nunderuse\nunencapsulated\nuninit\nuniqueptrparam\nunnamed2\nuse1\nusers'\nUTF\nutil\nv's\nv1\nv2\nv22\nva\nvararg\nvarargs\nvariables'\nvariadic\nvbase\nvd1\nvec\nVector0\nVector1\nVector2\nvid\nvirtuality\nvirtuals\nVLAs\nvolatile2\nvptr\nvr\nvtable\nvtbls\nvv\nw0\nwchar\nwebby\nwebcolors\nWG21\nWidgetUser\nWorkQueue\nx1\nx2\nx22\nxmax\nxor\nXs\ny1\ny2\nyears'\nyy\nZhuang\nzstring\nZubkov\nzz\n"
  },
  {
    "path": "scripts/nodejs/package.json",
    "content": "{\n    \"name\": \"CppCoreGuidelinesCheck\",\n    \"version\": \"0.0.0\",\n    \"description\": \"CppCoreGuidelines Check\",\n    \"private\": true,\n    \"dependencies\": {\n        \"remark\": \"^4.2.2\",\n        \"remark-lint\": \"^4.0.2\",\n        \"remark-lint-sentence-newline\": \"^2.0.0\",\n        \"remark-validate-links\": \"^4.1.0\"\n    }\n}\n"
  },
  {
    "path": "scripts/nodejs/remark/.remarkrc",
    "content": "{\n    \"presets\": [\"lint-recommended\", \"lint-consistent\"],\n    \"plugins\": {\n        \"remark-lint\": {\n            \"unordered-list-marker-style\": \"consistent\",\n            \"list-item-bullet-indent\": true,\n            \"list-item-indent\": false,\n            \"list-item-spacing\": false,\n            \"no-html\": false,\n            \"maximum-line-length\": false,\n            \"no-file-name-mixed-case\": false,\n            \"heading-increment\": false,\n            \"no-multiple-toplevel-headings\": true,\n            \"no-consecutive-blank-lines\": false,\n            \"maximum-line-length\": 9000,\n            \"maximum-heading-length\": 300,\n            \"no-heading-punctuation\": false,\n            \"no-duplicate-headings\": false,\n            \"emphasis-marker\": \"*\",\n            \"no-tabs\": true,\n            \"blockquote-indentation\": false,\n            \"strong-marker\": \"*\"\n        }\n    },\n    \"settings\": {\n        \"bullet\": \"*\",\n        \"listItemIndent\": \"1\",\n        \"strong\": \"*\",\n        \"emphasis\": \"*\"\n    }\n}\n"
  },
  {
    "path": "scripts/python/Makefile.in",
    "content": ".PHONY: default\ndefault: all\n\n.PHONY: all\nall: \\\ncpplint-all\n\nCXX_SRCS := $(wildcard *.cpp)\n\n#### cpplint, check extracted sources using cpplint tool\nCXX_LINT := ${CXX_SRCS:.cpp=.lint}\n\n.PHONY: cpplint-all\ncpplint-all:\n\t@python  ../../python/cpplint_wrap.py  *.cpp\n\n"
  },
  {
    "path": "scripts/python/cpplint.py",
    "content": "#!/usr/bin/env python\n#\n# Copyright (c) 2009 Google Inc. All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are\n# met:\n#\n#    * Redistributions of source code must retain the above copyright\n# notice, this list of conditions and the following disclaimer.\n#    * Redistributions in binary form must reproduce the above\n# copyright notice, this list of conditions and the following disclaimer\n# in the documentation and/or other materials provided with the\n# distribution.\n#    * Neither the name of Google Inc. nor the names of its\n# contributors may be used to endorse or promote products derived from\n# this software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n# \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n\"\"\"Does google-lint on c++ files.\n\nThe goal of this script is to identify places in the code that *may*\nbe in non-compliance with google style.  It does not attempt to fix\nup these problems -- the point is to educate.  It does also not\nattempt to find all problems, or to ensure that everything it does\nfind is legitimately a problem.\n\nIn particular, we can get very confused by /* and // inside strings!\nWe do a small hack, which is to ignore //'s with \"'s after them on the\nsame line, but it is far from perfect (in either direction).\n\"\"\"\n\nimport codecs\nimport copy\nimport getopt\nimport glob\nimport itertools\nimport math  # for log\nimport os\nimport re\nimport sre_compile\nimport string\nimport sys\nimport unicodedata\nimport xml.etree.ElementTree\n\n# if empty, use defaults\n_header_extensions = set([])\n\n# if empty, use defaults\n_valid_extensions = set([])\n\n\n# Files with any of these extensions are considered to be\n# header files (and will undergo different style checks).\n# This set can be extended by using the --headers\n# option (also supported in CPPLINT.cfg)\ndef GetHeaderExtensions():\n  if not _header_extensions:\n    return set(['h', 'hpp', 'hxx', 'h++', 'cuh'])\n  return _header_extensions\n\n# The allowed extensions for file names\n# This is set by --extensions flag\ndef GetAllExtensions():\n  if not _valid_extensions:\n    return GetHeaderExtensions().union(set(['c', 'cc', 'cpp', 'cxx', 'c++', 'cu']))\n  return _valid_extensions\n\ndef GetNonHeaderExtensions():\n  return GetAllExtensions().difference(GetHeaderExtensions())\n\n\n_USAGE = \"\"\"\nSyntax: cpplint.py [--verbose=#] [--output=emacs|eclipse|vs7|junit]\n                   [--filter=-x,+y,...]\n                   [--counting=total|toplevel|detailed] [--repository=path]\n                   [--root=subdir] [--linelength=digits] [--recursive]\n                   [--exclude=path]\n                   [--headers=ext1,ext2]\n                   [--extensions=hpp,cpp,...]\n        <file> [file] ...\n\n  The style guidelines this tries to follow are those in\n    https://google.github.io/styleguide/cppguide.html\n\n  Every problem is given a confidence score from 1-5, with 5 meaning we are\n  certain of the problem, and 1 meaning it could be a legitimate construct.\n  This will miss some errors, and is not a substitute for a code review.\n\n  To suppress false-positive errors of a certain category, add a\n  'NOLINT(category)' comment to the line.  NOLINT or NOLINT(*)\n  suppresses errors of all categories on that line.\n\n  The files passed in will be linted; at least one file must be provided.\n  Default linted extensions are %s.\n  Other file types will be ignored.\n  Change the extensions with the --extensions flag.\n\n  Flags:\n\n    output=emacs|eclipse|vs7|junit\n      By default, the output is formatted to ease emacs parsing.  Output\n      compatible with eclipse (eclipse), Visual Studio (vs7), and JUnit\n      XML parsers such as those used in Jenkins and Bamboo may also be\n      used.  Other formats are unsupported.\n\n    verbose=#\n      Specify a number 0-5 to restrict errors to certain verbosity levels.\n      Errors with lower verbosity levels have lower confidence and are more\n      likely to be false positives.\n\n    quiet\n      Supress output other than linting errors, such as information about\n      which files have been processed and excluded.\n\n    filter=-x,+y,...\n      Specify a comma-separated list of category-filters to apply: only\n      error messages whose category names pass the filters will be printed.\n      (Category names are printed with the message and look like\n      \"[whitespace/indent]\".)  Filters are evaluated left to right.\n      \"-FOO\" and \"FOO\" means \"do not print categories that start with FOO\".\n      \"+FOO\" means \"do print categories that start with FOO\".\n\n      Examples: --filter=-whitespace,+whitespace/braces\n                --filter=whitespace,runtime/printf,+runtime/printf_format\n                --filter=-,+build/include_what_you_use\n\n      To see a list of all the categories used in cpplint, pass no arg:\n         --filter=\n\n    counting=total|toplevel|detailed\n      The total number of errors found is always printed. If\n      'toplevel' is provided, then the count of errors in each of\n      the top-level categories like 'build' and 'whitespace' will\n      also be printed. If 'detailed' is provided, then a count\n      is provided for each category like 'build/class'.\n\n    repository=path\n      The top level directory of the repository, used to derive the header\n      guard CPP variable. By default, this is determined by searching for a\n      path that contains .git, .hg, or .svn. When this flag is specified, the\n      given path is used instead. This option allows the header guard CPP\n      variable to remain consistent even if members of a team have different\n      repository root directories (such as when checking out a subdirectory\n      with SVN). In addition, users of non-mainstream version control systems\n      can use this flag to ensure readable header guard CPP variables.\n\n      Examples:\n        Assuming that Alice checks out ProjectName and Bob checks out\n        ProjectName/trunk and trunk contains src/chrome/ui/browser.h, then\n        with no --repository flag, the header guard CPP variable will be:\n\n        Alice => TRUNK_SRC_CHROME_BROWSER_UI_BROWSER_H_\n        Bob   => SRC_CHROME_BROWSER_UI_BROWSER_H_\n\n        If Alice uses the --repository=trunk flag and Bob omits the flag or\n        uses --repository=. then the header guard CPP variable will be:\n\n        Alice => SRC_CHROME_BROWSER_UI_BROWSER_H_\n        Bob   => SRC_CHROME_BROWSER_UI_BROWSER_H_\n\n    root=subdir\n      The root directory used for deriving header guard CPP variables. This\n      directory is relative to the top level directory of the repository which\n      by default is determined by searching for a directory that contains .git,\n      .hg, or .svn but can also be controlled with the --repository flag. If\n      the specified directory does not exist, this flag is ignored.\n\n      Examples:\n        Assuming that src is the top level directory of the repository, the\n        header guard CPP variables for src/chrome/browser/ui/browser.h are:\n\n        No flag => CHROME_BROWSER_UI_BROWSER_H_\n        --root=chrome => BROWSER_UI_BROWSER_H_\n        --root=chrome/browser => UI_BROWSER_H_\n\n    linelength=digits\n      This is the allowed line length for the project. The default value is\n      80 characters.\n\n      Examples:\n        --linelength=120\n\n    recursive\n      Search for files to lint recursively. Each directory given in the list\n      of files to be linted is replaced by all files that descend from that\n      directory. Files with extensions not in the valid extensions list are\n      excluded.\n\n    exclude=path\n      Exclude the given path from the list of files to be linted. Relative\n      paths are evaluated relative to the current directory and shell globbing\n      is performed. This flag can be provided multiple times to exclude\n      multiple files.\n\n      Examples:\n        --exclude=one.cc\n        --exclude=src/*.cc\n        --exclude=src/*.cc --exclude=test/*.cc\n\n    extensions=extension,extension,...\n      The allowed file extensions that cpplint will check\n\n      Examples:\n        --extensions=%s\n\n    headers=extension,extension,...\n      The allowed header extensions that cpplint will consider to be header files\n      (by default, only files with extensions %s\n      will be assumed to be headers)\n\n      Examples:\n        --headers=%s\n\n    cpplint.py supports per-directory configurations specified in CPPLINT.cfg\n    files. CPPLINT.cfg file can contain a number of key=value pairs.\n    Currently the following options are supported:\n\n      set noparent\n      filter=+filter1,-filter2,...\n      exclude_files=regex\n      linelength=80\n      root=subdir\n\n    \"set noparent\" option prevents cpplint from traversing directory tree\n    upwards looking for more .cfg files in parent directories. This option\n    is usually placed in the top-level project directory.\n\n    The \"filter\" option is similar in function to --filter flag. It specifies\n    message filters in addition to the |_DEFAULT_FILTERS| and those specified\n    through --filter command-line flag.\n\n    \"exclude_files\" allows to specify a regular expression to be matched against\n    a file name. If the expression matches, the file is skipped and not run\n    through the linter.\n\n    \"linelength\" specifies the allowed line length for the project.\n\n    The \"root\" option is similar in function to the --root flag (see example\n    above).\n\n    CPPLINT.cfg has an effect on files in the same directory and all\n    subdirectories, unless overridden by a nested configuration file.\n\n      Example file:\n        filter=-build/include_order,+build/include_alpha\n        exclude_files=.*\\\\.cc\n\n    The above example disables build/include_order warning and enables\n    build/include_alpha as well as excludes all .cc from being\n    processed by linter, in the current directory (where the .cfg\n    file is located) and all subdirectories.\n\"\"\" % (list(GetAllExtensions()),\n       ','.join(list(GetAllExtensions())),\n       GetHeaderExtensions(),\n       ','.join(GetHeaderExtensions()))\n\n# We categorize each error message we print.  Here are the categories.\n# We want an explicit list so we can list them all in cpplint --filter=.\n# If you add a new error message with a new category, add it to the list\n# here!  cpplint_unittest.py should tell you if you forget to do this.\n_ERROR_CATEGORIES = [\n    'build/class',\n    'build/c++11',\n    'build/c++14',\n    'build/c++tr1',\n    'build/deprecated',\n    'build/endif_comment',\n    'build/explicit_make_pair',\n    'build/forward_decl',\n    'build/header_guard',\n    'build/include',\n    'build/include_subdir',\n    'build/include_alpha',\n    'build/include_order',\n    'build/include_what_you_use',\n    'build/namespaces_literals',\n    'build/namespaces',\n    'build/printf_format',\n    'build/storage_class',\n    'legal/copyright',\n    'readability/alt_tokens',\n    'readability/braces',\n    'readability/casting',\n    'readability/check',\n    'readability/constructors',\n    'readability/fn_size',\n    'readability/inheritance',\n    'readability/multiline_comment',\n    'readability/multiline_string',\n    'readability/namespace',\n    'readability/nolint',\n    'readability/nul',\n    'readability/strings',\n    'readability/todo',\n    'readability/utf8',\n    'runtime/arrays',\n    'runtime/casting',\n    'runtime/explicit',\n    'runtime/int',\n    'runtime/init',\n    'runtime/invalid_increment',\n    'runtime/member_string_references',\n    'runtime/memset',\n    'runtime/indentation_namespace',\n    'runtime/operator',\n    'runtime/printf',\n    'runtime/printf_format',\n    'runtime/references',\n    'runtime/string',\n    'runtime/threadsafe_fn',\n    'runtime/vlog',\n    'whitespace/blank_line',\n    'whitespace/braces',\n    'whitespace/comma',\n    'whitespace/comments',\n    'whitespace/empty_conditional_body',\n    'whitespace/empty_if_body',\n    'whitespace/empty_loop_body',\n    'whitespace/end_of_line',\n    'whitespace/ending_newline',\n    'whitespace/forcolon',\n    'whitespace/indent',\n    'whitespace/line_length',\n    'whitespace/newline',\n    'whitespace/operators',\n    'whitespace/parens',\n    'whitespace/semicolon',\n    'whitespace/tab',\n    'whitespace/todo',\n    ]\n\n# These error categories are no longer enforced by cpplint, but for backwards-\n# compatibility they may still appear in NOLINT comments.\n_LEGACY_ERROR_CATEGORIES = [\n    'readability/streams',\n    'readability/function',\n    ]\n\n# The default state of the category filter. This is overridden by the --filter=\n# flag. By default all errors are on, so only add here categories that should be\n# off by default (i.e., categories that must be enabled by the --filter= flags).\n# All entries here should start with a '-' or '+', as in the --filter= flag.\n_DEFAULT_FILTERS = ['-build/include_alpha']\n\n# The default list of categories suppressed for C (not C++) files.\n_DEFAULT_C_SUPPRESSED_CATEGORIES = [\n    'readability/casting',\n    ]\n\n# The default list of categories suppressed for Linux Kernel files.\n_DEFAULT_KERNEL_SUPPRESSED_CATEGORIES = [\n    'whitespace/tab',\n    ]\n\n# We used to check for high-bit characters, but after much discussion we\n# decided those were OK, as long as they were in UTF-8 and didn't represent\n# hard-coded international strings, which belong in a separate i18n file.\n\n# C++ headers\n_CPP_HEADERS = frozenset([\n    # Legacy\n    'algobase.h',\n    'algo.h',\n    'alloc.h',\n    'builtinbuf.h',\n    'bvector.h',\n    'complex.h',\n    'defalloc.h',\n    'deque.h',\n    'editbuf.h',\n    'fstream.h',\n    'function.h',\n    'hash_map',\n    'hash_map.h',\n    'hash_set',\n    'hash_set.h',\n    'hashtable.h',\n    'heap.h',\n    'indstream.h',\n    'iomanip.h',\n    'iostream.h',\n    'istream.h',\n    'iterator.h',\n    'list.h',\n    'map.h',\n    'multimap.h',\n    'multiset.h',\n    'ostream.h',\n    'pair.h',\n    'parsestream.h',\n    'pfstream.h',\n    'procbuf.h',\n    'pthread_alloc',\n    'pthread_alloc.h',\n    'rope',\n    'rope.h',\n    'ropeimpl.h',\n    'set.h',\n    'slist',\n    'slist.h',\n    'stack.h',\n    'stdiostream.h',\n    'stl_alloc.h',\n    'stl_relops.h',\n    'streambuf.h',\n    'stream.h',\n    'strfile.h',\n    'strstream.h',\n    'tempbuf.h',\n    'tree.h',\n    'type_traits.h',\n    'vector.h',\n    # 17.6.1.2 C++ library headers\n    'algorithm',\n    'array',\n    'atomic',\n    'bitset',\n    'chrono',\n    'codecvt',\n    'complex',\n    'condition_variable',\n    'deque',\n    'exception',\n    'forward_list',\n    'fstream',\n    'functional',\n    'future',\n    'initializer_list',\n    'iomanip',\n    'ios',\n    'iosfwd',\n    'iostream',\n    'istream',\n    'iterator',\n    'limits',\n    'list',\n    'locale',\n    'map',\n    'memory',\n    'mutex',\n    'new',\n    'numeric',\n    'ostream',\n    'queue',\n    'random',\n    'ratio',\n    'regex',\n    'scoped_allocator',\n    'set',\n    'sstream',\n    'stack',\n    'stdexcept',\n    'streambuf',\n    'string',\n    'strstream',\n    'system_error',\n    'thread',\n    'tuple',\n    'typeindex',\n    'typeinfo',\n    'type_traits',\n    'unordered_map',\n    'unordered_set',\n    'utility',\n    'valarray',\n    'vector',\n    # 17.6.1.2 C++ headers for C library facilities\n    'cassert',\n    'ccomplex',\n    'cctype',\n    'cerrno',\n    'cfenv',\n    'cfloat',\n    'cinttypes',\n    'ciso646',\n    'climits',\n    'clocale',\n    'cmath',\n    'csetjmp',\n    'csignal',\n    'cstdalign',\n    'cstdarg',\n    'cstdbool',\n    'cstddef',\n    'cstdint',\n    'cstdio',\n    'cstdlib',\n    'cstring',\n    'ctgmath',\n    'ctime',\n    'cuchar',\n    'cwchar',\n    'cwctype',\n    ])\n\n# Type names\n_TYPES = re.compile(\n    r'^(?:'\n    # [dcl.type.simple]\n    r'(char(16_t|32_t)?)|wchar_t|'\n    r'bool|short|int|long|signed|unsigned|float|double|'\n    # [support.types]\n    r'(ptrdiff_t|size_t|max_align_t|nullptr_t)|'\n    # [cstdint.syn]\n    r'(u?int(_fast|_least)?(8|16|32|64)_t)|'\n    r'(u?int(max|ptr)_t)|'\n    r')$')\n\n\n# These headers are excluded from [build/include] and [build/include_order]\n# checks:\n# - Anything not following google file name conventions (containing an\n#   uppercase character, such as Python.h or nsStringAPI.h, for example).\n# - Lua headers.\n_THIRD_PARTY_HEADERS_PATTERN = re.compile(\n    r'^(?:[^/]*[A-Z][^/]*\\.h|lua\\.h|lauxlib\\.h|lualib\\.h)$')\n\n# Pattern for matching FileInfo.BaseName() against test file name\n_test_suffixes = ['_test', '_regtest', '_unittest']\n_TEST_FILE_SUFFIX = '(' + '|'.join(_test_suffixes) + r')$'\n\n# Pattern that matches only complete whitespace, possibly across multiple lines.\n_EMPTY_CONDITIONAL_BODY_PATTERN = re.compile(r'^\\s*$', re.DOTALL)\n\n# Assertion macros.  These are defined in base/logging.h and\n# testing/base/public/gunit.h.\n_CHECK_MACROS = [\n    'DCHECK', 'CHECK',\n    'EXPECT_TRUE', 'ASSERT_TRUE',\n    'EXPECT_FALSE', 'ASSERT_FALSE',\n    ]\n\n# Replacement macros for CHECK/DCHECK/EXPECT_TRUE/EXPECT_FALSE\n_CHECK_REPLACEMENT = dict([(macro_var, {}) for macro_var in _CHECK_MACROS])\n\nfor op, replacement in [('==', 'EQ'), ('!=', 'NE'),\n                        ('>=', 'GE'), ('>', 'GT'),\n                        ('<=', 'LE'), ('<', 'LT')]:\n  _CHECK_REPLACEMENT['DCHECK'][op] = 'DCHECK_%s' % replacement\n  _CHECK_REPLACEMENT['CHECK'][op] = 'CHECK_%s' % replacement\n  _CHECK_REPLACEMENT['EXPECT_TRUE'][op] = 'EXPECT_%s' % replacement\n  _CHECK_REPLACEMENT['ASSERT_TRUE'][op] = 'ASSERT_%s' % replacement\n\nfor op, inv_replacement in [('==', 'NE'), ('!=', 'EQ'),\n                            ('>=', 'LT'), ('>', 'LE'),\n                            ('<=', 'GT'), ('<', 'GE')]:\n  _CHECK_REPLACEMENT['EXPECT_FALSE'][op] = 'EXPECT_%s' % inv_replacement\n  _CHECK_REPLACEMENT['ASSERT_FALSE'][op] = 'ASSERT_%s' % inv_replacement\n\n# Alternative tokens and their replacements.  For full list, see section 2.5\n# Alternative tokens [lex.digraph] in the C++ standard.\n#\n# Digraphs (such as '%:') are not included here since it's a mess to\n# match those on a word boundary.\n_ALT_TOKEN_REPLACEMENT = {\n    'and': '&&',\n    'bitor': '|',\n    'or': '||',\n    'xor': '^',\n    'compl': '~',\n    'bitand': '&',\n    'and_eq': '&=',\n    'or_eq': '|=',\n    'xor_eq': '^=',\n    'not': '!',\n    'not_eq': '!='\n    }\n\n# Compile regular expression that matches all the above keywords.  The \"[ =()]\"\n# bit is meant to avoid matching these keywords outside of boolean expressions.\n#\n# False positives include C-style multi-line comments and multi-line strings\n# but those have always been troublesome for cpplint.\n_ALT_TOKEN_REPLACEMENT_PATTERN = re.compile(\n    r'[ =()](' + ('|'.join(_ALT_TOKEN_REPLACEMENT.keys())) + r')(?=[ (]|$)')\n\n\n# These constants define types of headers for use with\n# _IncludeState.CheckNextIncludeOrder().\n_C_SYS_HEADER = 1\n_CPP_SYS_HEADER = 2\n_LIKELY_MY_HEADER = 3\n_POSSIBLE_MY_HEADER = 4\n_OTHER_HEADER = 5\n\n# These constants define the current inline assembly state\n_NO_ASM = 0       # Outside of inline assembly block\n_INSIDE_ASM = 1   # Inside inline assembly block\n_END_ASM = 2      # Last line of inline assembly block\n_BLOCK_ASM = 3    # The whole block is an inline assembly block\n\n# Match start of assembly blocks\n_MATCH_ASM = re.compile(r'^\\s*(?:asm|_asm|__asm|__asm__)'\n                        r'(?:\\s+(volatile|__volatile__))?'\n                        r'\\s*[{(]')\n\n# Match strings that indicate we're working on a C (not C++) file.\n_SEARCH_C_FILE = re.compile(r'\\b(?:LINT_C_FILE|'\n                            r'vim?:\\s*.*(\\s*|:)filetype=c(\\s*|:|$))')\n\n# Match string that indicates we're working on a Linux Kernel file.\n_SEARCH_KERNEL_FILE = re.compile(r'\\b(?:LINT_KERNEL_FILE)')\n\n_regexp_compile_cache = {}\n\n# {str, set(int)}: a map from error categories to sets of linenumbers\n# on which those errors are expected and should be suppressed.\n_error_suppressions = {}\n\n# The root directory used for deriving header guard CPP variable.\n# This is set by --root flag.\n_root = None\n\n# The top level repository directory. If set, _root is calculated relative to\n# this directory instead of the directory containing version control artifacts.\n# This is set by the --repository flag.\n_repository = None\n\n# Files to exclude from linting. This is set by the --exclude flag.\n_excludes = None\n\n# Whether to supress PrintInfo messages\n_quiet = False\n\n# The allowed line length of files.\n# This is set by --linelength flag.\n_line_length = 80\n\ntry:\n  xrange(1, 0)\nexcept NameError:\n  #  -- pylint: disable=redefined-builtin\n  xrange = range\n\ntry:\n  unicode\nexcept NameError:\n  #  -- pylint: disable=redefined-builtin\n  basestring = unicode = str\n\ntry:\n  long(2)\nexcept NameError:\n  #  -- pylint: disable=redefined-builtin\n  long = int\n\nif sys.version_info < (3,):\n  #  -- pylint: disable=no-member\n  # BINARY_TYPE = str\n  itervalues = dict.itervalues\n  iteritems = dict.iteritems\nelse:\n  # BINARY_TYPE = bytes\n  itervalues = dict.values\n  iteritems = dict.items\n\ndef unicode_escape_decode(x):\n  if sys.version_info < (3,):\n    return codecs.unicode_escape_decode(x)[0]\n  else:\n    return x\n\n# {str, bool}: a map from error categories to booleans which indicate if the\n# category should be suppressed for every line.\n_global_error_suppressions = {}\n\n\n\n\ndef ParseNolintSuppressions(filename, raw_line, linenum, error):\n  \"\"\"Updates the global list of line error-suppressions.\n\n  Parses any NOLINT comments on the current line, updating the global\n  error_suppressions store.  Reports an error if the NOLINT comment\n  was malformed.\n\n  Args:\n    filename: str, the name of the input file.\n    raw_line: str, the line of input text, with comments.\n    linenum: int, the number of the current line.\n    error: function, an error handler.\n  \"\"\"\n  matched = Search(r'\\bNOLINT(NEXTLINE)?\\b(\\([^)]+\\))?', raw_line)\n  if matched:\n    if matched.group(1):\n      suppressed_line = linenum + 1\n    else:\n      suppressed_line = linenum\n    category = matched.group(2)\n    if category in (None, '(*)'):  # => \"suppress all\"\n      _error_suppressions.setdefault(None, set()).add(suppressed_line)\n    else:\n      if category.startswith('(') and category.endswith(')'):\n        category = category[1:-1]\n        if category in _ERROR_CATEGORIES:\n          _error_suppressions.setdefault(category, set()).add(suppressed_line)\n        elif category not in _LEGACY_ERROR_CATEGORIES:\n          error(filename, linenum, 'readability/nolint', 5,\n                'Unknown NOLINT error category: %s' % category)\n\n\ndef ProcessGlobalSuppresions(lines):\n  \"\"\"Updates the list of global error suppressions.\n\n  Parses any lint directives in the file that have global effect.\n\n  Args:\n    lines: An array of strings, each representing a line of the file, with the\n           last element being empty if the file is terminated with a newline.\n  \"\"\"\n  for line in lines:\n    if _SEARCH_C_FILE.search(line):\n      for category in _DEFAULT_C_SUPPRESSED_CATEGORIES:\n        _global_error_suppressions[category] = True\n    if _SEARCH_KERNEL_FILE.search(line):\n      for category in _DEFAULT_KERNEL_SUPPRESSED_CATEGORIES:\n        _global_error_suppressions[category] = True\n\n\ndef ResetNolintSuppressions():\n  \"\"\"Resets the set of NOLINT suppressions to empty.\"\"\"\n  _error_suppressions.clear()\n  _global_error_suppressions.clear()\n\n\ndef IsErrorSuppressedByNolint(category, linenum):\n  \"\"\"Returns true if the specified error category is suppressed on this line.\n\n  Consults the global error_suppressions map populated by\n  ParseNolintSuppressions/ProcessGlobalSuppresions/ResetNolintSuppressions.\n\n  Args:\n    category: str, the category of the error.\n    linenum: int, the current line number.\n  Returns:\n    bool, True iff the error should be suppressed due to a NOLINT comment or\n    global suppression.\n  \"\"\"\n  return (_global_error_suppressions.get(category, False) or\n          linenum in _error_suppressions.get(category, set()) or\n          linenum in _error_suppressions.get(None, set()))\n\n\ndef Match(pattern, s):\n  \"\"\"Matches the string with the pattern, caching the compiled regexp.\"\"\"\n  # The regexp compilation caching is inlined in both Match and Search for\n  # performance reasons; factoring it out into a separate function turns out\n  # to be noticeably expensive.\n  if pattern not in _regexp_compile_cache:\n    _regexp_compile_cache[pattern] = sre_compile.compile(pattern)\n  return _regexp_compile_cache[pattern].match(s)\n\n\ndef ReplaceAll(pattern, rep, s):\n  \"\"\"Replaces instances of pattern in a string with a replacement.\n\n  The compiled regex is kept in a cache shared by Match and Search.\n\n  Args:\n    pattern: regex pattern\n    rep: replacement text\n    s: search string\n\n  Returns:\n    string with replacements made (or original string if no replacements)\n  \"\"\"\n  if pattern not in _regexp_compile_cache:\n    _regexp_compile_cache[pattern] = sre_compile.compile(pattern)\n  return _regexp_compile_cache[pattern].sub(rep, s)\n\n\ndef Search(pattern, s):\n  \"\"\"Searches the string for the pattern, caching the compiled regexp.\"\"\"\n  if pattern not in _regexp_compile_cache:\n    _regexp_compile_cache[pattern] = sre_compile.compile(pattern)\n  return _regexp_compile_cache[pattern].search(s)\n\n\ndef _IsSourceExtension(s):\n  \"\"\"File extension (excluding dot) matches a source file extension.\"\"\"\n  return s in GetNonHeaderExtensions()\n\n\nclass _IncludeState(object):\n  \"\"\"Tracks line numbers for includes, and the order in which includes appear.\n\n  include_list contains list of lists of (header, line number) pairs.\n  It's a lists of lists rather than just one flat list to make it\n  easier to update across preprocessor boundaries.\n\n  Call CheckNextIncludeOrder() once for each header in the file, passing\n  in the type constants defined above. Calls in an illegal order will\n  raise an _IncludeError with an appropriate error message.\n\n  \"\"\"\n  # self._section will move monotonically through this set. If it ever\n  # needs to move backwards, CheckNextIncludeOrder will raise an error.\n  _INITIAL_SECTION = 0\n  _MY_H_SECTION = 1\n  _C_SECTION = 2\n  _CPP_SECTION = 3\n  _OTHER_H_SECTION = 4\n\n  _TYPE_NAMES = {\n      _C_SYS_HEADER: 'C system header',\n      _CPP_SYS_HEADER: 'C++ system header',\n      _LIKELY_MY_HEADER: 'header this file implements',\n      _POSSIBLE_MY_HEADER: 'header this file may implement',\n      _OTHER_HEADER: 'other header',\n      }\n  _SECTION_NAMES = {\n      _INITIAL_SECTION: \"... nothing. (This can't be an error.)\",\n      _MY_H_SECTION: 'a header this file implements',\n      _C_SECTION: 'C system header',\n      _CPP_SECTION: 'C++ system header',\n      _OTHER_H_SECTION: 'other header',\n      }\n\n  def __init__(self):\n    self.include_list = [[]]\n    self._section = None\n    self._last_header = None\n    self.ResetSection('')\n\n  def FindHeader(self, header):\n    \"\"\"Check if a header has already been included.\n\n    Args:\n      header: header to check.\n    Returns:\n      Line number of previous occurrence, or -1 if the header has not\n      been seen before.\n    \"\"\"\n    for section_list in self.include_list:\n      for f in section_list:\n        if f[0] == header:\n          return f[1]\n    return -1\n\n  def ResetSection(self, directive):\n    \"\"\"Reset section checking for preprocessor directive.\n\n    Args:\n      directive: preprocessor directive (e.g. \"if\", \"else\").\n    \"\"\"\n    # The name of the current section.\n    self._section = self._INITIAL_SECTION\n    # The path of last found header.\n    self._last_header = ''\n\n    # Update list of includes.  Note that we never pop from the\n    # include list.\n    if directive in ('if', 'ifdef', 'ifndef'):\n      self.include_list.append([])\n    elif directive in ('else', 'elif'):\n      self.include_list[-1] = []\n\n  def SetLastHeader(self, header_path):\n    self._last_header = header_path\n\n  def CanonicalizeAlphabeticalOrder(self, header_path):\n    \"\"\"Returns a path canonicalized for alphabetical comparison.\n\n    - replaces \"-\" with \"_\" so they both cmp the same.\n    - removes '-inl' since we don't require them to be after the main header.\n    - lowercase everything, just in case.\n\n    Args:\n      header_path: Path to be canonicalized.\n\n    Returns:\n      Canonicalized path.\n    \"\"\"\n    return header_path.replace('-inl.h', '.h').replace('-', '_').lower()\n\n  def IsInAlphabeticalOrder(self, clean_lines, linenum, header_path):\n    \"\"\"Check if a header is in alphabetical order with the previous header.\n\n    Args:\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      header_path: Canonicalized header to be checked.\n\n    Returns:\n      Returns true if the header is in alphabetical order.\n    \"\"\"\n    # If previous section is different from current section, _last_header will\n    # be reset to empty string, so it's always less than current header.\n    #\n    # If previous line was a blank line, assume that the headers are\n    # intentionally sorted the way they are.\n    if (self._last_header > header_path and\n        Match(r'^\\s*#\\s*include\\b', clean_lines.elided[linenum - 1])):\n      return False\n    return True\n\n  def CheckNextIncludeOrder(self, header_type):\n    \"\"\"Returns a non-empty error message if the next header is out of order.\n\n    This function also updates the internal state to be ready to check\n    the next include.\n\n    Args:\n      header_type: One of the _XXX_HEADER constants defined above.\n\n    Returns:\n      The empty string if the header is in the right order, or an\n      error message describing what's wrong.\n\n    \"\"\"\n    error_message = ('Found %s after %s' %\n                     (self._TYPE_NAMES[header_type],\n                      self._SECTION_NAMES[self._section]))\n\n    last_section = self._section\n\n    if header_type == _C_SYS_HEADER:\n      if self._section <= self._C_SECTION:\n        self._section = self._C_SECTION\n      else:\n        self._last_header = ''\n        return error_message\n    elif header_type == _CPP_SYS_HEADER:\n      if self._section <= self._CPP_SECTION:\n        self._section = self._CPP_SECTION\n      else:\n        self._last_header = ''\n        return error_message\n    elif header_type == _LIKELY_MY_HEADER:\n      if self._section <= self._MY_H_SECTION:\n        self._section = self._MY_H_SECTION\n      else:\n        self._section = self._OTHER_H_SECTION\n    elif header_type == _POSSIBLE_MY_HEADER:\n      if self._section <= self._MY_H_SECTION:\n        self._section = self._MY_H_SECTION\n      else:\n        # This will always be the fallback because we're not sure\n        # enough that the header is associated with this file.\n        self._section = self._OTHER_H_SECTION\n    else:\n      assert header_type == _OTHER_HEADER\n      self._section = self._OTHER_H_SECTION\n\n    if last_section != self._section:\n      self._last_header = ''\n\n    return ''\n\n\nclass _CppLintState(object):\n  \"\"\"Maintains module-wide state..\"\"\"\n\n  def __init__(self):\n    self.verbose_level = 1  # global setting.\n    self.error_count = 0    # global count of reported errors\n    # filters to apply when emitting error messages\n    self.filters = _DEFAULT_FILTERS[:]\n    # backup of filter list. Used to restore the state after each file.\n    self._filters_backup = self.filters[:]\n    self.counting = 'total'  # In what way are we counting errors?\n    self.errors_by_category = {}  # string to int dict storing error counts\n\n    # output format:\n    # \"emacs\" - format that emacs can parse (default)\n    # \"eclipse\" - format that eclipse can parse\n    # \"vs7\" - format that Microsoft Visual Studio 7 can parse\n    # \"junit\" - format that Jenkins, Bamboo, etc can parse\n    self.output_format = 'emacs'\n\n    # For JUnit output, save errors and failures until the end so that they\n    # can be written into the XML\n    self._junit_errors = []\n    self._junit_failures = []\n\n  def SetOutputFormat(self, output_format):\n    \"\"\"Sets the output format for errors.\"\"\"\n    self.output_format = output_format\n\n  def SetVerboseLevel(self, level):\n    \"\"\"Sets the module's verbosity, and returns the previous setting.\"\"\"\n    last_verbose_level = self.verbose_level\n    self.verbose_level = level\n    return last_verbose_level\n\n  def SetCountingStyle(self, counting_style):\n    \"\"\"Sets the module's counting options.\"\"\"\n    self.counting = counting_style\n\n  def SetFilters(self, filters):\n    \"\"\"Sets the error-message filters.\n\n    These filters are applied when deciding whether to emit a given\n    error message.\n\n    Args:\n      filters: A string of comma-separated filters (eg \"+whitespace/indent\").\n               Each filter should start with + or -; else we die.\n\n    Raises:\n      ValueError: The comma-separated filters did not all start with '+' or '-'.\n                  E.g. \"-,+whitespace,-whitespace/indent,whitespace/badfilter\"\n    \"\"\"\n    # Default filters always have less priority than the flag ones.\n    self.filters = _DEFAULT_FILTERS[:]\n    self.AddFilters(filters)\n\n  def AddFilters(self, filters):\n    \"\"\" Adds more filters to the existing list of error-message filters. \"\"\"\n    for filt in filters.split(','):\n      clean_filt = filt.strip()\n      if clean_filt:\n        self.filters.append(clean_filt)\n    for filt in self.filters:\n      if not (filt.startswith('+') or filt.startswith('-')):\n        raise ValueError('Every filter in --filters must start with + or -'\n                         ' (%s does not)' % filt)\n\n  def BackupFilters(self):\n    \"\"\" Saves the current filter list to backup storage.\"\"\"\n    self._filters_backup = self.filters[:]\n\n  def RestoreFilters(self):\n    \"\"\" Restores filters previously backed up.\"\"\"\n    self.filters = self._filters_backup[:]\n\n  def ResetErrorCounts(self):\n    \"\"\"Sets the module's error statistic back to zero.\"\"\"\n    self.error_count = 0\n    self.errors_by_category = {}\n\n  def IncrementErrorCount(self, category):\n    \"\"\"Bumps the module's error statistic.\"\"\"\n    self.error_count += 1\n    if self.counting in ('toplevel', 'detailed'):\n      if self.counting != 'detailed':\n        category = category.split('/')[0]\n      if category not in self.errors_by_category:\n        self.errors_by_category[category] = 0\n      self.errors_by_category[category] += 1\n\n  def PrintErrorCounts(self):\n    \"\"\"Print a summary of errors by category, and the total.\"\"\"\n    for category, count in sorted(iteritems(self.errors_by_category)):\n      self.PrintInfo('Category \\'%s\\' errors found: %d\\n' %\n                       (category, count))\n    if self.error_count > 0:\n      self.PrintInfo('Total errors found: %d\\n' % self.error_count)\n\n  def PrintInfo(self, message):\n    if not _quiet and self.output_format != 'junit':\n      sys.stderr.write(message)\n\n  def PrintError(self, message):\n    if self.output_format == 'junit':\n      self._junit_errors.append(message)\n    else:\n      sys.stderr.write(message)\n\n  def AddJUnitFailure(self, filename, linenum, message, category, confidence):\n    self._junit_failures.append((filename, linenum, message, category,\n        confidence))\n\n  def FormatJUnitXML(self):\n    num_errors = len(self._junit_errors)\n    num_failures = len(self._junit_failures)\n\n    testsuite = xml.etree.ElementTree.Element('testsuite')\n    testsuite.attrib['name'] = 'cpplint'\n    testsuite.attrib['errors'] = str(num_errors)\n    testsuite.attrib['failures'] = str(num_failures)\n\n    if num_errors == 0 and num_failures == 0:\n      testsuite.attrib['tests'] = str(1)\n      xml.etree.ElementTree.SubElement(testsuite, 'testcase', name='passed')\n\n    else:\n      testsuite.attrib['tests'] = str(num_errors + num_failures)\n      if num_errors > 0:\n        testcase = xml.etree.ElementTree.SubElement(testsuite, 'testcase')\n        testcase.attrib['name'] = 'errors'\n        error = xml.etree.ElementTree.SubElement(testcase, 'error')\n        error.text = '\\n'.join(self._junit_errors)\n      if num_failures > 0:\n        # Group failures by file\n        failed_file_order = []\n        failures_by_file = {}\n        for failure in self._junit_failures:\n          failed_file = failure[0]\n          if failed_file not in failed_file_order:\n            failed_file_order.append(failed_file)\n            failures_by_file[failed_file] = []\n          failures_by_file[failed_file].append(failure)\n        # Create a testcase for each file\n        for failed_file in failed_file_order:\n          failures = failures_by_file[failed_file]\n          testcase = xml.etree.ElementTree.SubElement(testsuite, 'testcase')\n          testcase.attrib['name'] = failed_file\n          failure = xml.etree.ElementTree.SubElement(testcase, 'failure')\n          template = '{0}: {1} [{2}] [{3}]'\n          texts = [template.format(f[1], f[2], f[3], f[4]) for f in failures]\n          failure.text = '\\n'.join(texts)\n\n    xml_decl = '<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\\n'\n    return xml_decl + xml.etree.ElementTree.tostring(testsuite, 'utf-8').decode('utf-8')\n\n\n_cpplint_state = _CppLintState()\n\n\ndef _OutputFormat():\n  \"\"\"Gets the module's output format.\"\"\"\n  return _cpplint_state.output_format\n\n\ndef _SetOutputFormat(output_format):\n  \"\"\"Sets the module's output format.\"\"\"\n  _cpplint_state.SetOutputFormat(output_format)\n\n\ndef _VerboseLevel():\n  \"\"\"Returns the module's verbosity setting.\"\"\"\n  return _cpplint_state.verbose_level\n\n\ndef _SetVerboseLevel(level):\n  \"\"\"Sets the module's verbosity, and returns the previous setting.\"\"\"\n  return _cpplint_state.SetVerboseLevel(level)\n\n\ndef _SetCountingStyle(level):\n  \"\"\"Sets the module's counting options.\"\"\"\n  _cpplint_state.SetCountingStyle(level)\n\n\ndef _Filters():\n  \"\"\"Returns the module's list of output filters, as a list.\"\"\"\n  return _cpplint_state.filters\n\n\ndef _SetFilters(filters):\n  \"\"\"Sets the module's error-message filters.\n\n  These filters are applied when deciding whether to emit a given\n  error message.\n\n  Args:\n    filters: A string of comma-separated filters (eg \"whitespace/indent\").\n             Each filter should start with + or -; else we die.\n  \"\"\"\n  _cpplint_state.SetFilters(filters)\n\ndef _AddFilters(filters):\n  \"\"\"Adds more filter overrides.\n\n  Unlike _SetFilters, this function does not reset the current list of filters\n  available.\n\n  Args:\n    filters: A string of comma-separated filters (eg \"whitespace/indent\").\n             Each filter should start with + or -; else we die.\n  \"\"\"\n  _cpplint_state.AddFilters(filters)\n\ndef _BackupFilters():\n  \"\"\" Saves the current filter list to backup storage.\"\"\"\n  _cpplint_state.BackupFilters()\n\ndef _RestoreFilters():\n  \"\"\" Restores filters previously backed up.\"\"\"\n  _cpplint_state.RestoreFilters()\n\nclass _FunctionState(object):\n  \"\"\"Tracks current function name and the number of lines in its body.\"\"\"\n\n  _NORMAL_TRIGGER = 250  # for --v=0, 500 for --v=1, etc.\n  _TEST_TRIGGER = 400    # about 50% more than _NORMAL_TRIGGER.\n\n  def __init__(self):\n    self.in_a_function = False\n    self.lines_in_function = 0\n    self.current_function = ''\n\n  def Begin(self, function_name):\n    \"\"\"Start analyzing function body.\n\n    Args:\n      function_name: The name of the function being tracked.\n    \"\"\"\n    self.in_a_function = True\n    self.lines_in_function = 0\n    self.current_function = function_name\n\n  def Count(self):\n    \"\"\"Count line in current function body.\"\"\"\n    if self.in_a_function:\n      self.lines_in_function += 1\n\n  def Check(self, error, filename, linenum):\n    \"\"\"Report if too many lines in function body.\n\n    Args:\n      error: The function to call with any errors found.\n      filename: The name of the current file.\n      linenum: The number of the line to check.\n    \"\"\"\n    if not self.in_a_function:\n      return\n\n    if Match(r'T(EST|est)', self.current_function):\n      base_trigger = self._TEST_TRIGGER\n    else:\n      base_trigger = self._NORMAL_TRIGGER\n    trigger = base_trigger * 2**_VerboseLevel()\n\n    if self.lines_in_function > trigger:\n      error_level = int(math.log(self.lines_in_function / base_trigger, 2))\n      # 50 => 0, 100 => 1, 200 => 2, 400 => 3, 800 => 4, 1600 => 5, ...\n      if error_level > 5:\n        error_level = 5\n      error(filename, linenum, 'readability/fn_size', error_level,\n            'Small and focused functions are preferred:'\n            ' %s has %d non-comment lines'\n            ' (error triggered by exceeding %d lines).'  % (\n                self.current_function, self.lines_in_function, trigger))\n\n  def End(self):\n    \"\"\"Stop analyzing function body.\"\"\"\n    self.in_a_function = False\n\n\nclass _IncludeError(Exception):\n  \"\"\"Indicates a problem with the include order in a file.\"\"\"\n  pass\n\n\nclass FileInfo(object):\n  \"\"\"Provides utility functions for filenames.\n\n  FileInfo provides easy access to the components of a file's path\n  relative to the project root.\n  \"\"\"\n\n  def __init__(self, filename):\n    self._filename = filename\n\n  def FullName(self):\n    \"\"\"Make Windows paths like Unix.\"\"\"\n    return os.path.abspath(self._filename).replace('\\\\', '/')\n\n  def RepositoryName(self):\n    r\"\"\"FullName after removing the local path to the repository.\n\n    If we have a real absolute path name here we can try to do something smart:\n    detecting the root of the checkout and truncating /path/to/checkout from\n    the name so that we get header guards that don't include things like\n    \"C:\\Documents and Settings\\...\" or \"/home/username/...\" in them and thus\n    people on different computers who have checked the source out to different\n    locations won't see bogus errors.\n    \"\"\"\n    fullname = self.FullName()\n\n    if os.path.exists(fullname):\n      project_dir = os.path.dirname(fullname)\n\n      # If the user specified a repository path, it exists, and the file is\n      # contained in it, use the specified repository path\n      if _repository:\n        repo = FileInfo(_repository).FullName()\n        root_dir = project_dir\n        while os.path.exists(root_dir):\n          # allow case insensitive compare on Windows\n          if os.path.normcase(root_dir) == os.path.normcase(repo):\n            return os.path.relpath(fullname, root_dir).replace('\\\\', '/')\n          one_up_dir = os.path.dirname(root_dir)\n          if one_up_dir == root_dir:\n            break\n          root_dir = one_up_dir\n\n      if os.path.exists(os.path.join(project_dir, \".svn\")):\n        # If there's a .svn file in the current directory, we recursively look\n        # up the directory tree for the top of the SVN checkout\n        root_dir = project_dir\n        one_up_dir = os.path.dirname(root_dir)\n        while os.path.exists(os.path.join(one_up_dir, \".svn\")):\n          root_dir = os.path.dirname(root_dir)\n          one_up_dir = os.path.dirname(one_up_dir)\n\n        prefix = os.path.commonprefix([root_dir, project_dir])\n        return fullname[len(prefix) + 1:]\n\n      # Not SVN <= 1.6? Try to find a git, hg, or svn top level directory by\n      # searching up from the current path.\n      root_dir = current_dir = os.path.dirname(fullname)\n      while current_dir != os.path.dirname(current_dir):\n        if (os.path.exists(os.path.join(current_dir, \".git\")) or\n            os.path.exists(os.path.join(current_dir, \".hg\")) or\n            os.path.exists(os.path.join(current_dir, \".svn\"))):\n          root_dir = current_dir\n        current_dir = os.path.dirname(current_dir)\n\n      if (os.path.exists(os.path.join(root_dir, \".git\")) or\n          os.path.exists(os.path.join(root_dir, \".hg\")) or\n          os.path.exists(os.path.join(root_dir, \".svn\"))):\n        prefix = os.path.commonprefix([root_dir, project_dir])\n        return fullname[len(prefix) + 1:]\n\n    # Don't know what to do; header guard warnings may be wrong...\n    return fullname\n\n  def Split(self):\n    \"\"\"Splits the file into the directory, basename, and extension.\n\n    For 'chrome/browser/browser.cc', Split() would\n    return ('chrome/browser', 'browser', '.cc')\n\n    Returns:\n      A tuple of (directory, basename, extension).\n    \"\"\"\n\n    googlename = self.RepositoryName()\n    project, rest = os.path.split(googlename)\n    return (project,) + os.path.splitext(rest)\n\n  def BaseName(self):\n    \"\"\"File base name - text after the final slash, before the final period.\"\"\"\n    return self.Split()[1]\n\n  def Extension(self):\n    \"\"\"File extension - text following the final period, includes that period.\"\"\"\n    return self.Split()[2]\n\n  def NoExtension(self):\n    \"\"\"File has no source file extension.\"\"\"\n    return '/'.join(self.Split()[0:2])\n\n  def IsSource(self):\n    \"\"\"File has a source file extension.\"\"\"\n    return _IsSourceExtension(self.Extension()[1:])\n\n\ndef _ShouldPrintError(category, confidence, linenum):\n  \"\"\"If confidence >= verbose, category passes filter and is not suppressed.\"\"\"\n\n  # There are three ways we might decide not to print an error message:\n  # a \"NOLINT(category)\" comment appears in the source,\n  # the verbosity level isn't high enough, or the filters filter it out.\n  if IsErrorSuppressedByNolint(category, linenum):\n    return False\n\n  if confidence < _cpplint_state.verbose_level:\n    return False\n\n  is_filtered = False\n  for one_filter in _Filters():\n    if one_filter.startswith('-'):\n      if category.startswith(one_filter[1:]):\n        is_filtered = True\n    elif one_filter.startswith('+'):\n      if category.startswith(one_filter[1:]):\n        is_filtered = False\n    else:\n      assert False  # should have been checked for in SetFilter.\n  if is_filtered:\n    return False\n\n  return True\n\n\ndef Error(filename, linenum, category, confidence, message):\n  \"\"\"Logs the fact we've found a lint error.\n\n  We log where the error was found, and also our confidence in the error,\n  that is, how certain we are this is a legitimate style regression, and\n  not a misidentification or a use that's sometimes justified.\n\n  False positives can be suppressed by the use of\n  \"cpplint(category)\"  comments on the offending line.  These are\n  parsed into _error_suppressions.\n\n  Args:\n    filename: The name of the file containing the error.\n    linenum: The number of the line containing the error.\n    category: A string used to describe the \"category\" this bug\n      falls under: \"whitespace\", say, or \"runtime\".  Categories\n      may have a hierarchy separated by slashes: \"whitespace/indent\".\n    confidence: A number from 1-5 representing a confidence score for\n      the error, with 5 meaning that we are certain of the problem,\n      and 1 meaning that it could be a legitimate construct.\n    message: The error message.\n  \"\"\"\n  if _ShouldPrintError(category, confidence, linenum):\n    _cpplint_state.IncrementErrorCount(category)\n    if _cpplint_state.output_format == 'vs7':\n      _cpplint_state.PrintError('%s(%s): warning: %s  [%s] [%d]\\n' % (\n          filename, linenum, message, category, confidence))\n    elif _cpplint_state.output_format == 'eclipse':\n      sys.stderr.write('%s:%s: warning: %s  [%s] [%d]\\n' % (\n          filename, linenum, message, category, confidence))\n    elif _cpplint_state.output_format == 'junit':\n        _cpplint_state.AddJUnitFailure(filename, linenum, message, category,\n            confidence)\n    else:\n      final_message = '%s:%s:  %s  [%s] [%d]\\n' % (\n          filename, linenum, message, category, confidence)\n      sys.stderr.write(final_message)\n\n# Matches standard C++ escape sequences per 2.13.2.3 of the C++ standard.\n_RE_PATTERN_CLEANSE_LINE_ESCAPES = re.compile(\n    r'\\\\([abfnrtv?\"\\\\\\']|\\d+|x[0-9a-fA-F]+)')\n# Match a single C style comment on the same line.\n_RE_PATTERN_C_COMMENTS = r'/\\*(?:[^*]|\\*(?!/))*\\*/'\n# Matches multi-line C style comments.\n# This RE is a little bit more complicated than one might expect, because we\n# have to take care of space removals tools so we can handle comments inside\n# statements better.\n# The current rule is: We only clear spaces from both sides when we're at the\n# end of the line. Otherwise, we try to remove spaces from the right side,\n# if this doesn't work we try on left side but only if there's a non-character\n# on the right.\n_RE_PATTERN_CLEANSE_LINE_C_COMMENTS = re.compile(\n    r'(\\s*' + _RE_PATTERN_C_COMMENTS + r'\\s*$|' +\n    _RE_PATTERN_C_COMMENTS + r'\\s+|' +\n    r'\\s+' + _RE_PATTERN_C_COMMENTS + r'(?=\\W)|' +\n    _RE_PATTERN_C_COMMENTS + r')')\n\n\ndef IsCppString(line):\n  \"\"\"Does line terminate so, that the next symbol is in string constant.\n\n  This function does not consider single-line nor multi-line comments.\n\n  Args:\n    line: is a partial line of code starting from the 0..n.\n\n  Returns:\n    True, if next character appended to 'line' is inside a\n    string constant.\n  \"\"\"\n\n  line = line.replace(r'\\\\', 'XX')  # after this, \\\\\" does not match to \\\"\n  return ((line.count('\"') - line.count(r'\\\"') - line.count(\"'\\\"'\")) & 1) == 1\n\n\ndef CleanseRawStrings(raw_lines):\n  \"\"\"Removes C++11 raw strings from lines.\n\n    Before:\n      static const char kData[] = R\"(\n          multi-line string\n          )\";\n\n    After:\n      static const char kData[] = \"\"\n          (replaced by blank line)\n          \"\";\n\n  Args:\n    raw_lines: list of raw lines.\n\n  Returns:\n    list of lines with C++11 raw strings replaced by empty strings.\n  \"\"\"\n\n  delimiter = None\n  lines_without_raw_strings = []\n  for line in raw_lines:\n    if delimiter:\n      # Inside a raw string, look for the end\n      end = line.find(delimiter)\n      if end >= 0:\n        # Found the end of the string, match leading space for this\n        # line and resume copying the original lines, and also insert\n        # a \"\" on the last line.\n        leading_space = Match(r'^(\\s*)\\S', line)\n        line = leading_space.group(1) + '\"\"' + line[end + len(delimiter):]\n        delimiter = None\n      else:\n        # Haven't found the end yet, append a blank line.\n        line = '\"\"'\n\n    # Look for beginning of a raw string, and replace them with\n    # empty strings.  This is done in a loop to handle multiple raw\n    # strings on the same line.\n    while delimiter is None:\n      # Look for beginning of a raw string.\n      # See 2.14.15 [lex.string] for syntax.\n      #\n      # Once we have matched a raw string, we check the prefix of the\n      # line to make sure that the line is not part of a single line\n      # comment.  It's done this way because we remove raw strings\n      # before removing comments as opposed to removing comments\n      # before removing raw strings.  This is because there are some\n      # cpplint checks that requires the comments to be preserved, but\n      # we don't want to check comments that are inside raw strings.\n      matched = Match(r'^(.*?)\\b(?:R|u8R|uR|UR|LR)\"([^\\s\\\\()]*)\\((.*)$', line)\n      if (matched and\n          not Match(r'^([^\\'\"]|\\'(\\\\.|[^\\'])*\\'|\"(\\\\.|[^\"])*\")*//',\n                    matched.group(1))):\n        delimiter = ')' + matched.group(2) + '\"'\n\n        end = matched.group(3).find(delimiter)\n        if end >= 0:\n          # Raw string ended on same line\n          line = (matched.group(1) + '\"\"' +\n                  matched.group(3)[end + len(delimiter):])\n          delimiter = None\n        else:\n          # Start of a multi-line raw string\n          line = matched.group(1) + '\"\"'\n      else:\n        break\n\n    lines_without_raw_strings.append(line)\n\n  # TODO(unknown): if delimiter is not None here, we might want to\n  # emit a warning for unterminated string.\n  return lines_without_raw_strings\n\n\ndef FindNextMultiLineCommentStart(lines, lineix):\n  \"\"\"Find the beginning marker for a multiline comment.\"\"\"\n  while lineix < len(lines):\n    if lines[lineix].strip().startswith('/*'):\n      # Only return this marker if the comment goes beyond this line\n      if lines[lineix].strip().find('*/', 2) < 0:\n        return lineix\n    lineix += 1\n  return len(lines)\n\n\ndef FindNextMultiLineCommentEnd(lines, lineix):\n  \"\"\"We are inside a comment, find the end marker.\"\"\"\n  while lineix < len(lines):\n    if lines[lineix].strip().endswith('*/'):\n      return lineix\n    lineix += 1\n  return len(lines)\n\n\ndef RemoveMultiLineCommentsFromRange(lines, begin, end):\n  \"\"\"Clears a range of lines for multi-line comments.\"\"\"\n  # Having // dummy comments makes the lines non-empty, so we will not get\n  # unnecessary blank line warnings later in the code.\n  for i in range(begin, end):\n    lines[i] = '/**/'\n\n\ndef RemoveMultiLineComments(filename, lines, error):\n  \"\"\"Removes multiline (c-style) comments from lines.\"\"\"\n  lineix = 0\n  while lineix < len(lines):\n    lineix_begin = FindNextMultiLineCommentStart(lines, lineix)\n    if lineix_begin >= len(lines):\n      return\n    lineix_end = FindNextMultiLineCommentEnd(lines, lineix_begin)\n    if lineix_end >= len(lines):\n      error(filename, lineix_begin + 1, 'readability/multiline_comment', 5,\n            'Could not find end of multi-line comment')\n      return\n    RemoveMultiLineCommentsFromRange(lines, lineix_begin, lineix_end + 1)\n    lineix = lineix_end + 1\n\n\ndef CleanseComments(line):\n  \"\"\"Removes //-comments and single-line C-style /* */ comments.\n\n  Args:\n    line: A line of C++ source.\n\n  Returns:\n    The line with single-line comments removed.\n  \"\"\"\n  commentpos = line.find('//')\n  if commentpos != -1 and not IsCppString(line[:commentpos]):\n    line = line[:commentpos].rstrip()\n  # get rid of /* ... */\n  return _RE_PATTERN_CLEANSE_LINE_C_COMMENTS.sub('', line)\n\n\nclass CleansedLines(object):\n  \"\"\"Holds 4 copies of all lines with different preprocessing applied to them.\n\n  1) elided member contains lines without strings and comments.\n  2) lines member contains lines without comments.\n  3) raw_lines member contains all the lines without processing.\n  4) lines_without_raw_strings member is same as raw_lines, but with C++11 raw\n     strings removed.\n  All these members are of <type 'list'>, and of the same length.\n  \"\"\"\n\n  def __init__(self, lines):\n    self.elided = []\n    self.lines = []\n    self.raw_lines = lines\n    self.num_lines = len(lines)\n    self.lines_without_raw_strings = CleanseRawStrings(lines)\n    for linenum in range(len(self.lines_without_raw_strings)):\n      self.lines.append(CleanseComments(\n          self.lines_without_raw_strings[linenum]))\n      elided = self._CollapseStrings(self.lines_without_raw_strings[linenum])\n      self.elided.append(CleanseComments(elided))\n\n  def NumLines(self):\n    \"\"\"Returns the number of lines represented.\"\"\"\n    return self.num_lines\n\n  @staticmethod\n  def _CollapseStrings(elided):\n    \"\"\"Collapses strings and chars on a line to simple \"\" or '' blocks.\n\n    We nix strings first so we're not fooled by text like '\"http://\"'\n\n    Args:\n      elided: The line being processed.\n\n    Returns:\n      The line with collapsed strings.\n    \"\"\"\n    if _RE_PATTERN_INCLUDE.match(elided):\n      return elided\n\n    # Remove escaped characters first to make quote/single quote collapsing\n    # basic.  Things that look like escaped characters shouldn't occur\n    # outside of strings and chars.\n    elided = _RE_PATTERN_CLEANSE_LINE_ESCAPES.sub('', elided)\n\n    # Replace quoted strings and digit separators.  Both single quotes\n    # and double quotes are processed in the same loop, otherwise\n    # nested quotes wouldn't work.\n    collapsed = ''\n    while True:\n      # Find the first quote character\n      match = Match(r'^([^\\'\"]*)([\\'\"])(.*)$', elided)\n      if not match:\n        collapsed += elided\n        break\n      head, quote, tail = match.groups()\n\n      if quote == '\"':\n        # Collapse double quoted strings\n        second_quote = tail.find('\"')\n        if second_quote >= 0:\n          collapsed += head + '\"\"'\n          elided = tail[second_quote + 1:]\n        else:\n          # Unmatched double quote, don't bother processing the rest\n          # of the line since this is probably a multiline string.\n          collapsed += elided\n          break\n      else:\n        # Found single quote, check nearby text to eliminate digit separators.\n        #\n        # There is no special handling for floating point here, because\n        # the integer/fractional/exponent parts would all be parsed\n        # correctly as long as there are digits on both sides of the\n        # separator.  So we are fine as long as we don't see something\n        # like \"0.'3\" (gcc 4.9.0 will not allow this literal).\n        if Search(r'\\b(?:0[bBxX]?|[1-9])[0-9a-fA-F]*$', head):\n          match_literal = Match(r'^((?:\\'?[0-9a-zA-Z_])*)(.*)$', \"'\" + tail)\n          collapsed += head + match_literal.group(1).replace(\"'\", '')\n          elided = match_literal.group(2)\n        else:\n          second_quote = tail.find('\\'')\n          if second_quote >= 0:\n            collapsed += head + \"''\"\n            elided = tail[second_quote + 1:]\n          else:\n            # Unmatched single quote\n            collapsed += elided\n            break\n\n    return collapsed\n\n\ndef FindEndOfExpressionInLine(line, startpos, stack):\n  \"\"\"Find the position just after the end of current parenthesized expression.\n\n  Args:\n    line: a CleansedLines line.\n    startpos: start searching at this position.\n    stack: nesting stack at startpos.\n\n  Returns:\n    On finding matching end: (index just after matching end, None)\n    On finding an unclosed expression: (-1, None)\n    Otherwise: (-1, new stack at end of this line)\n  \"\"\"\n  for i in xrange(startpos, len(line)):\n    char = line[i]\n    if char in '([{':\n      # Found start of parenthesized expression, push to expression stack\n      stack.append(char)\n    elif char == '<':\n      # Found potential start of template argument list\n      if i > 0 and line[i - 1] == '<':\n        # Left shift operator\n        if stack and stack[-1] == '<':\n          stack.pop()\n          if not stack:\n            return (-1, None)\n      elif i > 0 and Search(r'\\boperator\\s*$', line[0:i]):\n        # operator<, don't add to stack\n        continue\n      else:\n        # Tentative start of template argument list\n        stack.append('<')\n    elif char in ')]}':\n      # Found end of parenthesized expression.\n      #\n      # If we are currently expecting a matching '>', the pending '<'\n      # must have been an operator.  Remove them from expression stack.\n      while stack and stack[-1] == '<':\n        stack.pop()\n      if not stack:\n        return (-1, None)\n      if ((stack[-1] == '(' and char == ')') or\n          (stack[-1] == '[' and char == ']') or\n          (stack[-1] == '{' and char == '}')):\n        stack.pop()\n        if not stack:\n          return (i + 1, None)\n      else:\n        # Mismatched parentheses\n        return (-1, None)\n    elif char == '>':\n      # Found potential end of template argument list.\n\n      # Ignore \"->\" and operator functions\n      if (i > 0 and\n          (line[i - 1] == '-' or Search(r'\\boperator\\s*$', line[0:i - 1]))):\n        continue\n\n      # Pop the stack if there is a matching '<'.  Otherwise, ignore\n      # this '>' since it must be an operator.\n      if stack:\n        if stack[-1] == '<':\n          stack.pop()\n          if not stack:\n            return (i + 1, None)\n    elif char == ';':\n      # Found something that look like end of statements.  If we are currently\n      # expecting a '>', the matching '<' must have been an operator, since\n      # template argument list should not contain statements.\n      while stack and stack[-1] == '<':\n        stack.pop()\n      if not stack:\n        return (-1, None)\n\n  # Did not find end of expression or unbalanced parentheses on this line\n  return (-1, stack)\n\n\ndef CloseExpression(clean_lines, linenum, pos):\n  \"\"\"If input points to ( or { or [ or <, finds the position that closes it.\n\n  If lines[linenum][pos] points to a '(' or '{' or '[' or '<', finds the\n  linenum/pos that correspond to the closing of the expression.\n\n  TODO(unknown): cpplint spends a fair bit of time matching parentheses.\n  Ideally we would want to index all opening and closing parentheses once\n  and have CloseExpression be just a simple lookup, but due to preprocessor\n  tricks, this is not so easy.\n\n  Args:\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    pos: A position on the line.\n\n  Returns:\n    A tuple (line, linenum, pos) pointer *past* the closing brace, or\n    (line, len(lines), -1) if we never find a close.  Note we ignore\n    strings and comments when matching; and the line we return is the\n    'cleansed' line at linenum.\n  \"\"\"\n\n  line = clean_lines.elided[linenum]\n  if (line[pos] not in '({[<') or Match(r'<[<=]', line[pos:]):\n    return (line, clean_lines.NumLines(), -1)\n\n  # Check first line\n  (end_pos, stack) = FindEndOfExpressionInLine(line, pos, [])\n  if end_pos > -1:\n    return (line, linenum, end_pos)\n\n  # Continue scanning forward\n  while stack and linenum < clean_lines.NumLines() - 1:\n    linenum += 1\n    line = clean_lines.elided[linenum]\n    (end_pos, stack) = FindEndOfExpressionInLine(line, 0, stack)\n    if end_pos > -1:\n      return (line, linenum, end_pos)\n\n  # Did not find end of expression before end of file, give up\n  return (line, clean_lines.NumLines(), -1)\n\n\ndef FindStartOfExpressionInLine(line, endpos, stack):\n  \"\"\"Find position at the matching start of current expression.\n\n  This is almost the reverse of FindEndOfExpressionInLine, but note\n  that the input position and returned position differs by 1.\n\n  Args:\n    line: a CleansedLines line.\n    endpos: start searching at this position.\n    stack: nesting stack at endpos.\n\n  Returns:\n    On finding matching start: (index at matching start, None)\n    On finding an unclosed expression: (-1, None)\n    Otherwise: (-1, new stack at beginning of this line)\n  \"\"\"\n  i = endpos\n  while i >= 0:\n    char = line[i]\n    if char in ')]}':\n      # Found end of expression, push to expression stack\n      stack.append(char)\n    elif char == '>':\n      # Found potential end of template argument list.\n      #\n      # Ignore it if it's a \"->\" or \">=\" or \"operator>\"\n      if (i > 0 and\n          (line[i - 1] == '-' or\n           Match(r'\\s>=\\s', line[i - 1:]) or\n           Search(r'\\boperator\\s*$', line[0:i]))):\n        i -= 1\n      else:\n        stack.append('>')\n    elif char == '<':\n      # Found potential start of template argument list\n      if i > 0 and line[i - 1] == '<':\n        # Left shift operator\n        i -= 1\n      else:\n        # If there is a matching '>', we can pop the expression stack.\n        # Otherwise, ignore this '<' since it must be an operator.\n        if stack and stack[-1] == '>':\n          stack.pop()\n          if not stack:\n            return (i, None)\n    elif char in '([{':\n      # Found start of expression.\n      #\n      # If there are any unmatched '>' on the stack, they must be\n      # operators.  Remove those.\n      while stack and stack[-1] == '>':\n        stack.pop()\n      if not stack:\n        return (-1, None)\n      if ((char == '(' and stack[-1] == ')') or\n          (char == '[' and stack[-1] == ']') or\n          (char == '{' and stack[-1] == '}')):\n        stack.pop()\n        if not stack:\n          return (i, None)\n      else:\n        # Mismatched parentheses\n        return (-1, None)\n    elif char == ';':\n      # Found something that look like end of statements.  If we are currently\n      # expecting a '<', the matching '>' must have been an operator, since\n      # template argument list should not contain statements.\n      while stack and stack[-1] == '>':\n        stack.pop()\n      if not stack:\n        return (-1, None)\n\n    i -= 1\n\n  return (-1, stack)\n\n\ndef ReverseCloseExpression(clean_lines, linenum, pos):\n  \"\"\"If input points to ) or } or ] or >, finds the position that opens it.\n\n  If lines[linenum][pos] points to a ')' or '}' or ']' or '>', finds the\n  linenum/pos that correspond to the opening of the expression.\n\n  Args:\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    pos: A position on the line.\n\n  Returns:\n    A tuple (line, linenum, pos) pointer *at* the opening brace, or\n    (line, 0, -1) if we never find the matching opening brace.  Note\n    we ignore strings and comments when matching; and the line we\n    return is the 'cleansed' line at linenum.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n  if line[pos] not in ')}]>':\n    return (line, 0, -1)\n\n  # Check last line\n  (start_pos, stack) = FindStartOfExpressionInLine(line, pos, [])\n  if start_pos > -1:\n    return (line, linenum, start_pos)\n\n  # Continue scanning backward\n  while stack and linenum > 0:\n    linenum -= 1\n    line = clean_lines.elided[linenum]\n    (start_pos, stack) = FindStartOfExpressionInLine(line, len(line) - 1, stack)\n    if start_pos > -1:\n      return (line, linenum, start_pos)\n\n  # Did not find start of expression before beginning of file, give up\n  return (line, 0, -1)\n\n\ndef CheckForCopyright(filename, lines, error):\n  \"\"\"Logs an error if no Copyright message appears at the top of the file.\"\"\"\n\n  # We'll say it should occur by line 10. Don't forget there's a\n  # dummy line at the front.\n  for line in range(1, min(len(lines), 11)):\n    if re.search(r'Copyright', lines[line], re.I): break\n  else:                       # means no copyright line was found\n    error(filename, 0, 'legal/copyright', 5,\n          'No copyright message found.  '\n          'You should have a line: \"Copyright [year] <Copyright Owner>\"')\n\n\ndef GetIndentLevel(line):\n  \"\"\"Return the number of leading spaces in line.\n\n  Args:\n    line: A string to check.\n\n  Returns:\n    An integer count of leading spaces, possibly zero.\n  \"\"\"\n  indent = Match(r'^( *)\\S', line)\n  if indent:\n    return len(indent.group(1))\n  else:\n    return 0\n\n\ndef GetHeaderGuardCPPVariable(filename):\n  \"\"\"Returns the CPP variable that should be used as a header guard.\n\n  Args:\n    filename: The name of a C++ header file.\n\n  Returns:\n    The CPP variable that should be used as a header guard in the\n    named file.\n\n  \"\"\"\n\n  # Restores original filename in case that cpplint is invoked from Emacs's\n  # flymake.\n  filename = re.sub(r'_flymake\\.h$', '.h', filename)\n  filename = re.sub(r'/\\.flymake/([^/]*)$', r'/\\1', filename)\n  # Replace 'c++' with 'cpp'.\n  filename = filename.replace('C++', 'cpp').replace('c++', 'cpp')\n\n  fileinfo = FileInfo(filename)\n  file_path_from_root = fileinfo.RepositoryName()\n  if _root:\n    suffix = os.sep\n    # On Windows using directory separator will leave us with\n    # \"bogus escape error\" unless we properly escape regex.\n    if suffix == '\\\\':\n      suffix += '\\\\'\n    file_path_from_root = re.sub('^' + _root + suffix, '', file_path_from_root)\n  return re.sub(r'[^a-zA-Z0-9]', '_', file_path_from_root).upper() + '_'\n\n\ndef CheckForHeaderGuard(filename, clean_lines, error):\n  \"\"\"Checks that the file contains a header guard.\n\n  Logs an error if no #ifndef header guard is present.  For other\n  headers, checks that the full pathname is used.\n\n  Args:\n    filename: The name of the C++ header file.\n    clean_lines: A CleansedLines instance containing the file.\n    error: The function to call with any errors found.\n  \"\"\"\n\n  # Don't check for header guards if there are error suppression\n  # comments somewhere in this file.\n  #\n  # Because this is silencing a warning for a nonexistent line, we\n  # only support the very specific NOLINT(build/header_guard) syntax,\n  # and not the general NOLINT or NOLINT(*) syntax.\n  raw_lines = clean_lines.lines_without_raw_strings\n  for i in raw_lines:\n    if Search(r'//\\s*NOLINT\\(build/header_guard\\)', i):\n      return\n\n  # Allow pragma once instead of header guards\n  for i in raw_lines:\n    if Search(r'^\\s*#pragma\\s+once', i):\n      return\n\n  cppvar = GetHeaderGuardCPPVariable(filename)\n\n  ifndef = ''\n  ifndef_linenum = 0\n  define = ''\n  endif = ''\n  endif_linenum = 0\n  for linenum, line in enumerate(raw_lines):\n    linesplit = line.split()\n    if len(linesplit) >= 2:\n      # find the first occurrence of #ifndef and #define, save arg\n      if not ifndef and linesplit[0] == '#ifndef':\n        # set ifndef to the header guard presented on the #ifndef line.\n        ifndef = linesplit[1]\n        ifndef_linenum = linenum\n      if not define and linesplit[0] == '#define':\n        define = linesplit[1]\n    # find the last occurrence of #endif, save entire line\n    if line.startswith('#endif'):\n      endif = line\n      endif_linenum = linenum\n\n  if not ifndef or not define or ifndef != define:\n    error(filename, 0, 'build/header_guard', 5,\n          'No #ifndef header guard found, suggested CPP variable is: %s' %\n          cppvar)\n    return\n\n  # The guard should be PATH_FILE_H_, but we also allow PATH_FILE_H__\n  # for backward compatibility.\n  if ifndef != cppvar:\n    error_level = 0\n    if ifndef != cppvar + '_':\n      error_level = 5\n\n    ParseNolintSuppressions(filename, raw_lines[ifndef_linenum], ifndef_linenum,\n                            error)\n    error(filename, ifndef_linenum, 'build/header_guard', error_level,\n          '#ifndef header guard has wrong style, please use: %s' % cppvar)\n\n  # Check for \"//\" comments on endif line.\n  ParseNolintSuppressions(filename, raw_lines[endif_linenum], endif_linenum,\n                          error)\n  match = Match(r'#endif\\s*//\\s*' + cppvar + r'(_)?\\b', endif)\n  if match:\n    if match.group(1) == '_':\n      # Issue low severity warning for deprecated double trailing underscore\n      error(filename, endif_linenum, 'build/header_guard', 0,\n            '#endif line should be \"#endif  // %s\"' % cppvar)\n    return\n\n  # Didn't find the corresponding \"//\" comment.  If this file does not\n  # contain any \"//\" comments at all, it could be that the compiler\n  # only wants \"/**/\" comments, look for those instead.\n  no_single_line_comments = True\n  for i in xrange(1, len(raw_lines) - 1):\n    line = raw_lines[i]\n    if Match(r'^(?:(?:\\'(?:\\.|[^\\'])*\\')|(?:\"(?:\\.|[^\"])*\")|[^\\'\"])*//', line):\n      no_single_line_comments = False\n      break\n\n  if no_single_line_comments:\n    match = Match(r'#endif\\s*/\\*\\s*' + cppvar + r'(_)?\\s*\\*/', endif)\n    if match:\n      if match.group(1) == '_':\n        # Low severity warning for double trailing underscore\n        error(filename, endif_linenum, 'build/header_guard', 0,\n              '#endif line should be \"#endif  /* %s */\"' % cppvar)\n      return\n\n  # Didn't find anything\n  error(filename, endif_linenum, 'build/header_guard', 5,\n        '#endif line should be \"#endif  // %s\"' % cppvar)\n\n\ndef CheckHeaderFileIncluded(filename, include_state, error):\n  \"\"\"Logs an error if a source file does not include its header.\"\"\"\n\n  # Do not check test files\n  fileinfo = FileInfo(filename)\n  if Search(_TEST_FILE_SUFFIX, fileinfo.BaseName()):\n    return\n\n  for ext in GetHeaderExtensions():\n      basefilename = filename[0:len(filename) - len(fileinfo.Extension())]\n      headerfile = basefilename + '.' + ext\n      if not os.path.exists(headerfile):\n        continue\n      headername = FileInfo(headerfile).RepositoryName()\n      first_include = None\n      for section_list in include_state.include_list:\n        for f in section_list:\n          if headername in f[0] or f[0] in headername:\n            return\n          if not first_include:\n            first_include = f[1]\n\n      error(filename, first_include, 'build/include', 5,\n            '%s should include its header file %s' % (fileinfo.RepositoryName(),\n                                                      headername))\n\n\ndef CheckForBadCharacters(filename, lines, error):\n  \"\"\"Logs an error for each line containing bad characters.\n\n  Two kinds of bad characters:\n\n  1. Unicode replacement characters: These indicate that either the file\n  contained invalid UTF-8 (likely) or Unicode replacement characters (which\n  it shouldn't).  Note that it's possible for this to throw off line\n  numbering if the invalid UTF-8 occurred adjacent to a newline.\n\n  2. NUL bytes.  These are problematic for some tools.\n\n  Args:\n    filename: The name of the current file.\n    lines: An array of strings, each representing a line of the file.\n    error: The function to call with any errors found.\n  \"\"\"\n  for linenum, line in enumerate(lines):\n    if unicode_escape_decode('\\ufffd') in line:\n      error(filename, linenum, 'readability/utf8', 5,\n            'Line contains invalid UTF-8 (or Unicode replacement character).')\n    if '\\0' in line:\n      error(filename, linenum, 'readability/nul', 5, 'Line contains NUL byte.')\n\n\ndef CheckForNewlineAtEOF(filename, lines, error):\n  \"\"\"Logs an error if there is no newline char at the end of the file.\n\n  Args:\n    filename: The name of the current file.\n    lines: An array of strings, each representing a line of the file.\n    error: The function to call with any errors found.\n  \"\"\"\n\n  # The array lines() was created by adding two newlines to the\n  # original file (go figure), then splitting on \\n.\n  # To verify that the file ends in \\n, we just have to make sure the\n  # last-but-two element of lines() exists and is empty.\n  if len(lines) < 3 or lines[-2]:\n    error(filename, len(lines) - 2, 'whitespace/ending_newline', 5,\n          'Could not find a newline character at the end of the file.')\n\n\ndef CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, error):\n  \"\"\"Logs an error if we see /* ... */ or \"...\" that extend past one line.\n\n  /* ... */ comments are legit inside macros, for one line.\n  Otherwise, we prefer // comments, so it's ok to warn about the\n  other.  Likewise, it's ok for strings to extend across multiple\n  lines, as long as a line continuation character (backslash)\n  terminates each line. Although not currently prohibited by the C++\n  style guide, it's ugly and unnecessary. We don't do well with either\n  in this lint program, so we warn about both.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n\n  # Remove all \\\\ (escaped backslashes) from the line. They are OK, and the\n  # second (escaped) slash may trigger later \\\" detection erroneously.\n  line = line.replace('\\\\\\\\', '')\n\n  if line.count('/*') > line.count('*/'):\n    error(filename, linenum, 'readability/multiline_comment', 5,\n          'Complex multi-line /*...*/-style comment found. '\n          'Lint may give bogus warnings.  '\n          'Consider replacing these with //-style comments, '\n          'with #if 0...#endif, '\n          'or with more clearly structured multi-line comments.')\n\n  if (line.count('\"') - line.count('\\\\\"')) % 2:\n    error(filename, linenum, 'readability/multiline_string', 5,\n          'Multi-line string (\"...\") found.  This lint script doesn\\'t '\n          'do well with such strings, and may give bogus warnings.  '\n          'Use C++11 raw strings or concatenation instead.')\n\n\n# (non-threadsafe name, thread-safe alternative, validation pattern)\n#\n# The validation pattern is used to eliminate false positives such as:\n#  _rand();               // false positive due to substring match.\n#  ->rand();              // some member function rand().\n#  ACMRandom rand(seed);  // some variable named rand.\n#  ISAACRandom rand();    // another variable named rand.\n#\n# Basically we require the return value of these functions to be used\n# in some expression context on the same line by matching on some\n# operator before the function name.  This eliminates constructors and\n# member function calls.\n_UNSAFE_FUNC_PREFIX = r'(?:[-+*/=%^&|(<]\\s*|>\\s+)'\n_THREADING_LIST = (\n    ('asctime(', 'asctime_r(', _UNSAFE_FUNC_PREFIX + r'asctime\\([^)]+\\)'),\n    ('ctime(', 'ctime_r(', _UNSAFE_FUNC_PREFIX + r'ctime\\([^)]+\\)'),\n    ('getgrgid(', 'getgrgid_r(', _UNSAFE_FUNC_PREFIX + r'getgrgid\\([^)]+\\)'),\n    ('getgrnam(', 'getgrnam_r(', _UNSAFE_FUNC_PREFIX + r'getgrnam\\([^)]+\\)'),\n    ('getlogin(', 'getlogin_r(', _UNSAFE_FUNC_PREFIX + r'getlogin\\(\\)'),\n    ('getpwnam(', 'getpwnam_r(', _UNSAFE_FUNC_PREFIX + r'getpwnam\\([^)]+\\)'),\n    ('getpwuid(', 'getpwuid_r(', _UNSAFE_FUNC_PREFIX + r'getpwuid\\([^)]+\\)'),\n    ('gmtime(', 'gmtime_r(', _UNSAFE_FUNC_PREFIX + r'gmtime\\([^)]+\\)'),\n    ('localtime(', 'localtime_r(', _UNSAFE_FUNC_PREFIX + r'localtime\\([^)]+\\)'),\n    ('rand(', 'rand_r(', _UNSAFE_FUNC_PREFIX + r'rand\\(\\)'),\n    ('strtok(', 'strtok_r(',\n     _UNSAFE_FUNC_PREFIX + r'strtok\\([^)]+\\)'),\n    ('ttyname(', 'ttyname_r(', _UNSAFE_FUNC_PREFIX + r'ttyname\\([^)]+\\)'),\n    )\n\n\ndef CheckPosixThreading(filename, clean_lines, linenum, error):\n  \"\"\"Checks for calls to thread-unsafe functions.\n\n  Much code has been originally written without consideration of\n  multi-threading. Also, engineers are relying on their old experience;\n  they have learned posix before threading extensions were added. These\n  tests guide the engineers to use thread-safe functions (when using\n  posix directly).\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n  for single_thread_func, multithread_safe_func, pattern in _THREADING_LIST:\n    # Additional pattern matching check to confirm that this is the\n    # function we are looking for\n    if Search(pattern, line):\n      error(filename, linenum, 'runtime/threadsafe_fn', 2,\n            'Consider using ' + multithread_safe_func +\n            '...) instead of ' + single_thread_func +\n            '...) for improved thread safety.')\n\n\ndef CheckVlogArguments(filename, clean_lines, linenum, error):\n  \"\"\"Checks that VLOG() is only used for defining a logging level.\n\n  For example, VLOG(2) is correct. VLOG(INFO), VLOG(WARNING), VLOG(ERROR), and\n  VLOG(FATAL) are not.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n  if Search(r'\\bVLOG\\((INFO|ERROR|WARNING|DFATAL|FATAL)\\)', line):\n    error(filename, linenum, 'runtime/vlog', 5,\n          'VLOG() should be used with numeric verbosity level.  '\n          'Use LOG() if you want symbolic severity levels.')\n\n# Matches invalid increment: *count++, which moves pointer instead of\n# incrementing a value.\n_RE_PATTERN_INVALID_INCREMENT = re.compile(\n    r'^\\s*\\*\\w+(\\+\\+|--);')\n\n\ndef CheckInvalidIncrement(filename, clean_lines, linenum, error):\n  \"\"\"Checks for invalid increment *count++.\n\n  For example following function:\n  void increment_counter(int* count) {\n    *count++;\n  }\n  is invalid, because it effectively does count++, moving pointer, and should\n  be replaced with ++*count, (*count)++ or *count += 1.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n  if _RE_PATTERN_INVALID_INCREMENT.match(line):\n    error(filename, linenum, 'runtime/invalid_increment', 5,\n          'Changing pointer instead of value (or unused value of operator*).')\n\n\ndef IsMacroDefinition(clean_lines, linenum):\n  if Search(r'^#define', clean_lines[linenum]):\n    return True\n\n  if linenum > 0 and Search(r'\\\\$', clean_lines[linenum - 1]):\n    return True\n\n  return False\n\n\ndef IsForwardClassDeclaration(clean_lines, linenum):\n  return Match(r'^\\s*(\\btemplate\\b)*.*class\\s+\\w+;\\s*$', clean_lines[linenum])\n\n\nclass _BlockInfo(object):\n  \"\"\"Stores information about a generic block of code.\"\"\"\n\n  def __init__(self, linenum, seen_open_brace):\n    self.starting_linenum = linenum\n    self.seen_open_brace = seen_open_brace\n    self.open_parentheses = 0\n    self.inline_asm = _NO_ASM\n    self.check_namespace_indentation = False\n\n  def CheckBegin(self, filename, clean_lines, linenum, error):\n    \"\"\"Run checks that applies to text up to the opening brace.\n\n    This is mostly for checking the text after the class identifier\n    and the \"{\", usually where the base class is specified.  For other\n    blocks, there isn't much to check, so we always pass.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.\n    \"\"\"\n    pass\n\n  def CheckEnd(self, filename, clean_lines, linenum, error):\n    \"\"\"Run checks that applies to text after the closing brace.\n\n    This is mostly used for checking end of namespace comments.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.\n    \"\"\"\n    pass\n\n  def IsBlockInfo(self):\n    \"\"\"Returns true if this block is a _BlockInfo.\n\n    This is convenient for verifying that an object is an instance of\n    a _BlockInfo, but not an instance of any of the derived classes.\n\n    Returns:\n      True for this class, False for derived classes.\n    \"\"\"\n    return self.__class__ == _BlockInfo\n\n\nclass _ExternCInfo(_BlockInfo):\n  \"\"\"Stores information about an 'extern \"C\"' block.\"\"\"\n\n  def __init__(self, linenum):\n    _BlockInfo.__init__(self, linenum, True)\n\n\nclass _ClassInfo(_BlockInfo):\n  \"\"\"Stores information about a class.\"\"\"\n\n  def __init__(self, name, class_or_struct, clean_lines, linenum):\n    _BlockInfo.__init__(self, linenum, False)\n    self.name = name\n    self.is_derived = False\n    self.check_namespace_indentation = True\n    if class_or_struct == 'struct':\n      self.access = 'public'\n      self.is_struct = True\n    else:\n      self.access = 'private'\n      self.is_struct = False\n\n    # Remember initial indentation level for this class.  Using raw_lines here\n    # instead of elided to account for leading comments.\n    self.class_indent = GetIndentLevel(clean_lines.raw_lines[linenum])\n\n    # Try to find the end of the class.  This will be confused by things like:\n    #   class A {\n    #   } *x = { ...\n    #\n    # But it's still good enough for CheckSectionSpacing.\n    self.last_line = 0\n    depth = 0\n    for i in range(linenum, clean_lines.NumLines()):\n      line = clean_lines.elided[i]\n      depth += line.count('{') - line.count('}')\n      if not depth:\n        self.last_line = i\n        break\n\n  def CheckBegin(self, filename, clean_lines, linenum, error):\n    # Look for a bare ':'\n    if Search('(^|[^:]):($|[^:])', clean_lines.elided[linenum]):\n      self.is_derived = True\n\n  def CheckEnd(self, filename, clean_lines, linenum, error):\n    # If there is a DISALLOW macro, it should appear near the end of\n    # the class.\n    seen_last_thing_in_class = False\n    for i in xrange(linenum - 1, self.starting_linenum, -1):\n      match = Search(\n          r'\\b(DISALLOW_COPY_AND_ASSIGN|DISALLOW_IMPLICIT_CONSTRUCTORS)\\(' +\n          self.name + r'\\)',\n          clean_lines.elided[i])\n      if match:\n        if seen_last_thing_in_class:\n          error(filename, i, 'readability/constructors', 3,\n                match.group(1) + ' should be the last thing in the class')\n        break\n\n      if not Match(r'^\\s*$', clean_lines.elided[i]):\n        seen_last_thing_in_class = True\n\n    # Check that closing brace is aligned with beginning of the class.\n    # Only do this if the closing brace is indented by only whitespaces.\n    # This means we will not check single-line class definitions.\n    indent = Match(r'^( *)\\}', clean_lines.elided[linenum])\n    if indent and len(indent.group(1)) != self.class_indent:\n      if self.is_struct:\n        parent = 'struct ' + self.name\n      else:\n        parent = 'class ' + self.name\n      error(filename, linenum, 'whitespace/indent', 3,\n            'Closing brace should be aligned with beginning of %s' % parent)\n\n\nclass _NamespaceInfo(_BlockInfo):\n  \"\"\"Stores information about a namespace.\"\"\"\n\n  def __init__(self, name, linenum):\n    _BlockInfo.__init__(self, linenum, False)\n    self.name = name or ''\n    self.check_namespace_indentation = True\n\n  def CheckEnd(self, filename, clean_lines, linenum, error):\n    \"\"\"Check end of namespace comments.\"\"\"\n    line = clean_lines.raw_lines[linenum]\n\n    # Check how many lines is enclosed in this namespace.  Don't issue\n    # warning for missing namespace comments if there aren't enough\n    # lines.  However, do apply checks if there is already an end of\n    # namespace comment and it's incorrect.\n    #\n    # TODO(unknown): We always want to check end of namespace comments\n    # if a namespace is large, but sometimes we also want to apply the\n    # check if a short namespace contained nontrivial things (something\n    # other than forward declarations).  There is currently no logic on\n    # deciding what these nontrivial things are, so this check is\n    # triggered by namespace size only, which works most of the time.\n    if (linenum - self.starting_linenum < 10\n        and not Match(r'^\\s*};*\\s*(//|/\\*).*\\bnamespace\\b', line)):\n      return\n\n    # Look for matching comment at end of namespace.\n    #\n    # Note that we accept C style \"/* */\" comments for terminating\n    # namespaces, so that code that terminate namespaces inside\n    # preprocessor macros can be cpplint clean.\n    #\n    # We also accept stuff like \"// end of namespace <name>.\" with the\n    # period at the end.\n    #\n    # Besides these, we don't accept anything else, otherwise we might\n    # get false negatives when existing comment is a substring of the\n    # expected namespace.\n    if self.name:\n      # Named namespace\n      if not Match((r'^\\s*};*\\s*(//|/\\*).*\\bnamespace\\s+' +\n                    re.escape(self.name) + r'[\\*/\\.\\\\\\s]*$'),\n                   line):\n        error(filename, linenum, 'readability/namespace', 5,\n              'Namespace should be terminated with \"// namespace %s\"' %\n              self.name)\n    else:\n      # Anonymous namespace\n      if not Match(r'^\\s*};*\\s*(//|/\\*).*\\bnamespace[\\*/\\.\\\\\\s]*$', line):\n        # If \"// namespace anonymous\" or \"// anonymous namespace (more text)\",\n        # mention \"// anonymous namespace\" as an acceptable form\n        if Match(r'^\\s*}.*\\b(namespace anonymous|anonymous namespace)\\b', line):\n          error(filename, linenum, 'readability/namespace', 5,\n                'Anonymous namespace should be terminated with \"// namespace\"'\n                ' or \"// anonymous namespace\"')\n        else:\n          error(filename, linenum, 'readability/namespace', 5,\n                'Anonymous namespace should be terminated with \"// namespace\"')\n\n\nclass _PreprocessorInfo(object):\n  \"\"\"Stores checkpoints of nesting stacks when #if/#else is seen.\"\"\"\n\n  def __init__(self, stack_before_if):\n    # The entire nesting stack before #if\n    self.stack_before_if = stack_before_if\n\n    # The entire nesting stack up to #else\n    self.stack_before_else = []\n\n    # Whether we have already seen #else or #elif\n    self.seen_else = False\n\n\nclass NestingState(object):\n  \"\"\"Holds states related to parsing braces.\"\"\"\n\n  def __init__(self):\n    # Stack for tracking all braces.  An object is pushed whenever we\n    # see a \"{\", and popped when we see a \"}\".  Only 3 types of\n    # objects are possible:\n    # - _ClassInfo: a class or struct.\n    # - _NamespaceInfo: a namespace.\n    # - _BlockInfo: some other type of block.\n    self.stack = []\n\n    # Top of the previous stack before each Update().\n    #\n    # Because the nesting_stack is updated at the end of each line, we\n    # had to do some convoluted checks to find out what is the current\n    # scope at the beginning of the line.  This check is simplified by\n    # saving the previous top of nesting stack.\n    #\n    # We could save the full stack, but we only need the top.  Copying\n    # the full nesting stack would slow down cpplint by ~10%.\n    self.previous_stack_top = []\n\n    # Stack of _PreprocessorInfo objects.\n    self.pp_stack = []\n\n  def SeenOpenBrace(self):\n    \"\"\"Check if we have seen the opening brace for the innermost block.\n\n    Returns:\n      True if we have seen the opening brace, False if the innermost\n      block is still expecting an opening brace.\n    \"\"\"\n    return (not self.stack) or self.stack[-1].seen_open_brace\n\n  def InNamespaceBody(self):\n    \"\"\"Check if we are currently one level inside a namespace body.\n\n    Returns:\n      True if top of the stack is a namespace block, False otherwise.\n    \"\"\"\n    return self.stack and isinstance(self.stack[-1], _NamespaceInfo)\n\n  def InExternC(self):\n    \"\"\"Check if we are currently one level inside an 'extern \"C\"' block.\n\n    Returns:\n      True if top of the stack is an extern block, False otherwise.\n    \"\"\"\n    return self.stack and isinstance(self.stack[-1], _ExternCInfo)\n\n  def InClassDeclaration(self):\n    \"\"\"Check if we are currently one level inside a class or struct declaration.\n\n    Returns:\n      True if top of the stack is a class/struct, False otherwise.\n    \"\"\"\n    return self.stack and isinstance(self.stack[-1], _ClassInfo)\n\n  def InAsmBlock(self):\n    \"\"\"Check if we are currently one level inside an inline ASM block.\n\n    Returns:\n      True if the top of the stack is a block containing inline ASM.\n    \"\"\"\n    return self.stack and self.stack[-1].inline_asm != _NO_ASM\n\n  def InTemplateArgumentList(self, clean_lines, linenum, pos):\n    \"\"\"Check if current position is inside template argument list.\n\n    Args:\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      pos: position just after the suspected template argument.\n    Returns:\n      True if (linenum, pos) is inside template arguments.\n    \"\"\"\n    while linenum < clean_lines.NumLines():\n      # Find the earliest character that might indicate a template argument\n      line = clean_lines.elided[linenum]\n      match = Match(r'^[^{};=\\[\\]\\.<>]*(.)', line[pos:])\n      if not match:\n        linenum += 1\n        pos = 0\n        continue\n      token = match.group(1)\n      pos += len(match.group(0))\n\n      # These things do not look like template argument list:\n      #   class Suspect {\n      #   class Suspect x; }\n      if token in ('{', '}', ';'): return False\n\n      # These things look like template argument list:\n      #   template <class Suspect>\n      #   template <class Suspect = default_value>\n      #   template <class Suspect[]>\n      #   template <class Suspect...>\n      if token in ('>', '=', '[', ']', '.'): return True\n\n      # Check if token is an unmatched '<'.\n      # If not, move on to the next character.\n      if token != '<':\n        pos += 1\n        if pos >= len(line):\n          linenum += 1\n          pos = 0\n        continue\n\n      # We can't be sure if we just find a single '<', and need to\n      # find the matching '>'.\n      (_, end_line, end_pos) = CloseExpression(clean_lines, linenum, pos - 1)\n      if end_pos < 0:\n        # Not sure if template argument list or syntax error in file\n        return False\n      linenum = end_line\n      pos = end_pos\n    return False\n\n  def UpdatePreprocessor(self, line):\n    \"\"\"Update preprocessor stack.\n\n    We need to handle preprocessors due to classes like this:\n      #ifdef SWIG\n      struct ResultDetailsPageElementExtensionPoint {\n      #else\n      struct ResultDetailsPageElementExtensionPoint : public Extension {\n      #endif\n\n    We make the following assumptions (good enough for most files):\n    - Preprocessor condition evaluates to true from #if up to first\n      #else/#elif/#endif.\n\n    - Preprocessor condition evaluates to false from #else/#elif up\n      to #endif.  We still perform lint checks on these lines, but\n      these do not affect nesting stack.\n\n    Args:\n      line: current line to check.\n    \"\"\"\n    if Match(r'^\\s*#\\s*(if|ifdef|ifndef)\\b', line):\n      # Beginning of #if block, save the nesting stack here.  The saved\n      # stack will allow us to restore the parsing state in the #else case.\n      self.pp_stack.append(_PreprocessorInfo(copy.deepcopy(self.stack)))\n    elif Match(r'^\\s*#\\s*(else|elif)\\b', line):\n      # Beginning of #else block\n      if self.pp_stack:\n        if not self.pp_stack[-1].seen_else:\n          # This is the first #else or #elif block.  Remember the\n          # whole nesting stack up to this point.  This is what we\n          # keep after the #endif.\n          self.pp_stack[-1].seen_else = True\n          self.pp_stack[-1].stack_before_else = copy.deepcopy(self.stack)\n\n        # Restore the stack to how it was before the #if\n        self.stack = copy.deepcopy(self.pp_stack[-1].stack_before_if)\n      else:\n        # TODO(unknown): unexpected #else, issue warning?\n        pass\n    elif Match(r'^\\s*#\\s*endif\\b', line):\n      # End of #if or #else blocks.\n      if self.pp_stack:\n        # If we saw an #else, we will need to restore the nesting\n        # stack to its former state before the #else, otherwise we\n        # will just continue from where we left off.\n        if self.pp_stack[-1].seen_else:\n          # Here we can just use a shallow copy since we are the last\n          # reference to it.\n          self.stack = self.pp_stack[-1].stack_before_else\n        # Drop the corresponding #if\n        self.pp_stack.pop()\n      else:\n        # TODO(unknown): unexpected #endif, issue warning?\n        pass\n\n  # TODO(unknown): Update() is too long, but we will refactor later.\n  def Update(self, filename, clean_lines, linenum, error):\n    \"\"\"Update nesting state with current line.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.\n    \"\"\"\n    line = clean_lines.elided[linenum]\n\n    # Remember top of the previous nesting stack.\n    #\n    # The stack is always pushed/popped and not modified in place, so\n    # we can just do a shallow copy instead of copy.deepcopy.  Using\n    # deepcopy would slow down cpplint by ~28%.\n    if self.stack:\n      self.previous_stack_top = self.stack[-1]\n    else:\n      self.previous_stack_top = None\n\n    # Update pp_stack\n    self.UpdatePreprocessor(line)\n\n    # Count parentheses.  This is to avoid adding struct arguments to\n    # the nesting stack.\n    if self.stack:\n      inner_block = self.stack[-1]\n      depth_change = line.count('(') - line.count(')')\n      inner_block.open_parentheses += depth_change\n\n      # Also check if we are starting or ending an inline assembly block.\n      if inner_block.inline_asm in (_NO_ASM, _END_ASM):\n        if (depth_change != 0 and\n            inner_block.open_parentheses == 1 and\n            _MATCH_ASM.match(line)):\n          # Enter assembly block\n          inner_block.inline_asm = _INSIDE_ASM\n        else:\n          # Not entering assembly block.  If previous line was _END_ASM,\n          # we will now shift to _NO_ASM state.\n          inner_block.inline_asm = _NO_ASM\n      elif (inner_block.inline_asm == _INSIDE_ASM and\n            inner_block.open_parentheses == 0):\n        # Exit assembly block\n        inner_block.inline_asm = _END_ASM\n\n    # Consume namespace declaration at the beginning of the line.  Do\n    # this in a loop so that we catch same line declarations like this:\n    #   namespace proto2 { namespace bridge { class MessageSet; } }\n    while True:\n      # Match start of namespace.  The \"\\b\\s*\" below catches namespace\n      # declarations even if it weren't followed by a whitespace, this\n      # is so that we don't confuse our namespace checker.  The\n      # missing spaces will be flagged by CheckSpacing.\n      namespace_decl_match = Match(r'^\\s*namespace\\b\\s*([:\\w]+)?(.*)$', line)\n      if not namespace_decl_match:\n        break\n\n      new_namespace = _NamespaceInfo(namespace_decl_match.group(1), linenum)\n      self.stack.append(new_namespace)\n\n      line = namespace_decl_match.group(2)\n      if line.find('{') != -1:\n        new_namespace.seen_open_brace = True\n        line = line[line.find('{') + 1:]\n\n    # Look for a class declaration in whatever is left of the line\n    # after parsing namespaces.  The regexp accounts for decorated classes\n    # such as in:\n    #   class LOCKABLE API Object {\n    #   };\n    class_decl_match = Match(\n        r'^(\\s*(?:template\\s*<[\\w\\s<>,:=]*>\\s*)?'\n        r'(class|struct)\\s+(?:[A-Z_]+\\s+)*(\\w+(?:::\\w+)*))'\n        r'(.*)$', line)\n    if (class_decl_match and\n        (not self.stack or self.stack[-1].open_parentheses == 0)):\n      # We do not want to accept classes that are actually template arguments:\n      #   template <class Ignore1,\n      #             class Ignore2 = Default<Args>,\n      #             template <Args> class Ignore3>\n      #   void Function() {};\n      #\n      # To avoid template argument cases, we scan forward and look for\n      # an unmatched '>'.  If we see one, assume we are inside a\n      # template argument list.\n      end_declaration = len(class_decl_match.group(1))\n      if not self.InTemplateArgumentList(clean_lines, linenum, end_declaration):\n        self.stack.append(_ClassInfo(\n            class_decl_match.group(3), class_decl_match.group(2),\n            clean_lines, linenum))\n        line = class_decl_match.group(4)\n\n    # If we have not yet seen the opening brace for the innermost block,\n    # run checks here.\n    if not self.SeenOpenBrace():\n      self.stack[-1].CheckBegin(filename, clean_lines, linenum, error)\n\n    # Update access control if we are inside a class/struct\n    if self.stack and isinstance(self.stack[-1], _ClassInfo):\n      classinfo = self.stack[-1]\n      access_match = Match(\n          r'^(.*)\\b(public|private|protected|signals)(\\s+(?:slots\\s*)?)?'\n          r':(?:[^:]|$)',\n          line)\n      if access_match:\n        classinfo.access = access_match.group(2)\n\n        # Check that access keywords are indented +1 space.  Skip this\n        # check if the keywords are not preceded by whitespaces.\n        indent = access_match.group(1)\n        if (len(indent) != classinfo.class_indent + 1 and\n            Match(r'^\\s*$', indent)):\n          if classinfo.is_struct:\n            parent = 'struct ' + classinfo.name\n          else:\n            parent = 'class ' + classinfo.name\n          slots = ''\n          if access_match.group(3):\n            slots = access_match.group(3)\n          error(filename, linenum, 'whitespace/indent', 3,\n                '%s%s: should be indented +1 space inside %s' % (\n                    access_match.group(2), slots, parent))\n\n    # Consume braces or semicolons from what's left of the line\n    while True:\n      # Match first brace, semicolon, or closed parenthesis.\n      matched = Match(r'^[^{;)}]*([{;)}])(.*)$', line)\n      if not matched:\n        break\n\n      token = matched.group(1)\n      if token == '{':\n        # If namespace or class hasn't seen a opening brace yet, mark\n        # namespace/class head as complete.  Push a new block onto the\n        # stack otherwise.\n        if not self.SeenOpenBrace():\n          self.stack[-1].seen_open_brace = True\n        elif Match(r'^extern\\s*\"[^\"]*\"\\s*\\{', line):\n          self.stack.append(_ExternCInfo(linenum))\n        else:\n          self.stack.append(_BlockInfo(linenum, True))\n          if _MATCH_ASM.match(line):\n            self.stack[-1].inline_asm = _BLOCK_ASM\n\n      elif token == ';' or token == ')':\n        # If we haven't seen an opening brace yet, but we already saw\n        # a semicolon, this is probably a forward declaration.  Pop\n        # the stack for these.\n        #\n        # Similarly, if we haven't seen an opening brace yet, but we\n        # already saw a closing parenthesis, then these are probably\n        # function arguments with extra \"class\" or \"struct\" keywords.\n        # Also pop these stack for these.\n        if not self.SeenOpenBrace():\n          self.stack.pop()\n      else:  # token == '}'\n        # Perform end of block checks and pop the stack.\n        if self.stack:\n          self.stack[-1].CheckEnd(filename, clean_lines, linenum, error)\n          self.stack.pop()\n      line = matched.group(2)\n\n  def InnermostClass(self):\n    \"\"\"Get class info on the top of the stack.\n\n    Returns:\n      A _ClassInfo object if we are inside a class, or None otherwise.\n    \"\"\"\n    for i in range(len(self.stack), 0, -1):\n      classinfo = self.stack[i - 1]\n      if isinstance(classinfo, _ClassInfo):\n        return classinfo\n    return None\n\n  def CheckCompletedBlocks(self, filename, error):\n    \"\"\"Checks that all classes and namespaces have been completely parsed.\n\n    Call this when all lines in a file have been processed.\n    Args:\n      filename: The name of the current file.\n      error: The function to call with any errors found.\n    \"\"\"\n    # Note: This test can result in false positives if #ifdef constructs\n    # get in the way of brace matching. See the testBuildClass test in\n    # cpplint_unittest.py for an example of this.\n    for obj in self.stack:\n      if isinstance(obj, _ClassInfo):\n        error(filename, obj.starting_linenum, 'build/class', 5,\n              'Failed to find complete declaration of class %s' %\n              obj.name)\n      elif isinstance(obj, _NamespaceInfo):\n        error(filename, obj.starting_linenum, 'build/namespaces', 5,\n              'Failed to find complete declaration of namespace %s' %\n              obj.name)\n\n\ndef CheckForNonStandardConstructs(filename, clean_lines, linenum,\n                                  nesting_state, error):\n  r\"\"\"Logs an error if we see certain non-ANSI constructs ignored by gcc-2.\n\n  Complain about several constructs which gcc-2 accepts, but which are\n  not standard C++.  Warning about these in lint is one way to ease the\n  transition to new compilers.\n  - put storage class first (e.g. \"static const\" instead of \"const static\").\n  - \"%lld\" instead of %qd\" in printf-type functions.\n  - \"%1$d\" is non-standard in printf-type functions.\n  - \"\\%\" is an undefined character escape sequence.\n  - text after #endif is not allowed.\n  - invalid inner-style forward declaration.\n  - >? and <? operators, and their >?= and <?= cousins.\n\n  Additionally, check for constructor/destructor style violations and reference\n  members, as it is very convenient to do so while checking for\n  gcc-2 compliance.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    nesting_state: A NestingState instance which maintains information about\n                   the current stack of nested blocks being parsed.\n    error: A callable to which errors are reported, which takes 4 arguments:\n           filename, line number, error level, and message\n  \"\"\"\n\n  # Remove comments from the line, but leave in strings for now.\n  line = clean_lines.lines[linenum]\n\n  if Search(r'printf\\s*\\(.*\".*%[-+ ]?\\d*q', line):\n    error(filename, linenum, 'runtime/printf_format', 3,\n          '%q in format strings is deprecated.  Use %ll instead.')\n\n  if Search(r'printf\\s*\\(.*\".*%\\d+\\$', line):\n    error(filename, linenum, 'runtime/printf_format', 2,\n          '%N$ formats are unconventional.  Try rewriting to avoid them.')\n\n  # Remove escaped backslashes before looking for undefined escapes.\n  line = line.replace('\\\\\\\\', '')\n\n  if Search(r'(\"|\\').*\\\\(%|\\[|\\(|{)', line):\n    error(filename, linenum, 'build/printf_format', 3,\n          '%, [, (, and { are undefined character escapes.  Unescape them.')\n\n  # For the rest, work with both comments and strings removed.\n  line = clean_lines.elided[linenum]\n\n  if Search(r'\\b(const|volatile|void|char|short|int|long'\n            r'|float|double|signed|unsigned'\n            r'|schar|u?int8|u?int16|u?int32|u?int64)'\n            r'\\s+(register|static|extern|typedef)\\b',\n            line):\n    error(filename, linenum, 'build/storage_class', 5,\n          'Storage-class specifier (static, extern, typedef, etc) should be '\n          'at the beginning of the declaration.')\n\n  if Match(r'\\s*#\\s*endif\\s*[^/\\s]+', line):\n    error(filename, linenum, 'build/endif_comment', 5,\n          'Uncommented text after #endif is non-standard.  Use a comment.')\n\n  if Match(r'\\s*class\\s+(\\w+\\s*::\\s*)+\\w+\\s*;', line):\n    error(filename, linenum, 'build/forward_decl', 5,\n          'Inner-style forward declarations are invalid.  Remove this line.')\n\n  if Search(r'(\\w+|[+-]?\\d+(\\.\\d*)?)\\s*(<|>)\\?=?\\s*(\\w+|[+-]?\\d+)(\\.\\d*)?',\n            line):\n    error(filename, linenum, 'build/deprecated', 3,\n          '>? and <? (max and min) operators are non-standard and deprecated.')\n\n  if Search(r'^\\s*const\\s*string\\s*&\\s*\\w+\\s*;', line):\n    # TODO(unknown): Could it be expanded safely to arbitrary references,\n    # without triggering too many false positives? The first\n    # attempt triggered 5 warnings for mostly benign code in the regtest, hence\n    # the restriction.\n    # Here's the original regexp, for the reference:\n    # type_name = r'\\w+((\\s*::\\s*\\w+)|(\\s*<\\s*\\w+?\\s*>))?'\n    # r'\\s*const\\s*' + type_name + '\\s*&\\s*\\w+\\s*;'\n    error(filename, linenum, 'runtime/member_string_references', 2,\n          'const string& members are dangerous. It is much better to use '\n          'alternatives, such as pointers or simple constants.')\n\n  # Everything else in this function operates on class declarations.\n  # Return early if the top of the nesting stack is not a class, or if\n  # the class head is not completed yet.\n  classinfo = nesting_state.InnermostClass()\n  if not classinfo or not classinfo.seen_open_brace:\n    return\n\n  # The class may have been declared with namespace or classname qualifiers.\n  # The constructor and destructor will not have those qualifiers.\n  base_classname = classinfo.name.split('::')[-1]\n\n  # Look for single-argument constructors that aren't marked explicit.\n  # Technically a valid construct, but against style.\n  explicit_constructor_match = Match(\n      r'\\s+(?:inline\\s+)?(explicit\\s+)?(?:inline\\s+)?%s\\s*'\n      r'\\(((?:[^()]|\\([^()]*\\))*)\\)'\n      % re.escape(base_classname),\n      line)\n\n  if explicit_constructor_match:\n    is_marked_explicit = explicit_constructor_match.group(1)\n\n    if not explicit_constructor_match.group(2):\n      constructor_args = []\n    else:\n      constructor_args = explicit_constructor_match.group(2).split(',')\n\n    # collapse arguments so that commas in template parameter lists and function\n    # argument parameter lists don't split arguments in two\n    i = 0\n    while i < len(constructor_args):\n      constructor_arg = constructor_args[i]\n      while (constructor_arg.count('<') > constructor_arg.count('>') or\n             constructor_arg.count('(') > constructor_arg.count(')')):\n        constructor_arg += ',' + constructor_args[i + 1]\n        del constructor_args[i + 1]\n      constructor_args[i] = constructor_arg\n      i += 1\n\n    variadic_args = [arg for arg in constructor_args if '&&...' in arg]\n    defaulted_args = [arg for arg in constructor_args if '=' in arg]\n    noarg_constructor = (not constructor_args or  # empty arg list\n                         # 'void' arg specifier\n                         (len(constructor_args) == 1 and\n                          constructor_args[0].strip() == 'void'))\n    onearg_constructor = ((len(constructor_args) == 1 and  # exactly one arg\n                           not noarg_constructor) or\n                          # all but at most one arg defaulted\n                          (len(constructor_args) >= 1 and\n                           not noarg_constructor and\n                           len(defaulted_args) >= len(constructor_args) - 1) or\n                          # variadic arguments with zero or one argument\n                          (len(constructor_args) <= 2 and\n                           len(variadic_args) >= 1))\n    initializer_list_constructor = bool(\n        onearg_constructor and\n        Search(r'\\bstd\\s*::\\s*initializer_list\\b', constructor_args[0]))\n    copy_constructor = bool(\n        onearg_constructor and\n        Match(r'(const\\s+)?%s(\\s*<[^>]*>)?(\\s+const)?\\s*(?:<\\w+>\\s*)?&'\n              % re.escape(base_classname), constructor_args[0].strip()))\n\n    if (not is_marked_explicit and\n        onearg_constructor and\n        not initializer_list_constructor and\n        not copy_constructor):\n      if defaulted_args or variadic_args:\n        error(filename, linenum, 'runtime/explicit', 5,\n              'Constructors callable with one argument '\n              'should be marked explicit.')\n      else:\n        error(filename, linenum, 'runtime/explicit', 5,\n              'Single-parameter constructors should be marked explicit.')\n    elif is_marked_explicit and not onearg_constructor:\n      if noarg_constructor:\n        error(filename, linenum, 'runtime/explicit', 5,\n              'Zero-parameter constructors should not be marked explicit.')\n\n\ndef CheckSpacingForFunctionCall(filename, clean_lines, linenum, error):\n  \"\"\"Checks for the correctness of various spacing around function calls.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n\n  # Since function calls often occur inside if/for/while/switch\n  # expressions - which have their own, more liberal conventions - we\n  # first see if we should be looking inside such an expression for a\n  # function call, to which we can apply more strict standards.\n  fncall = line    # if there's no control flow construct, look at whole line\n  for pattern in (r'\\bif\\s*\\((.*)\\)\\s*{',\n                  r'\\bfor\\s*\\((.*)\\)\\s*{',\n                  r'\\bwhile\\s*\\((.*)\\)\\s*[{;]',\n                  r'\\bswitch\\s*\\((.*)\\)\\s*{'):\n    match = Search(pattern, line)\n    if match:\n      fncall = match.group(1)    # look inside the parens for function calls\n      break\n\n  # Except in if/for/while/switch, there should never be space\n  # immediately inside parens (eg \"f( 3, 4 )\").  We make an exception\n  # for nested parens ( (a+b) + c ).  Likewise, there should never be\n  # a space before a ( when it's a function argument.  I assume it's a\n  # function argument when the char before the whitespace is legal in\n  # a function name (alnum + _) and we're not starting a macro. Also ignore\n  # pointers and references to arrays and functions coz they're too tricky:\n  # we use a very simple way to recognize these:\n  # \" (something)(maybe-something)\" or\n  # \" (something)(maybe-something,\" or\n  # \" (something)[something]\"\n  # Note that we assume the contents of [] to be short enough that\n  # they'll never need to wrap.\n  if (  # Ignore control structures.\n      not Search(r'\\b(if|for|while|switch|return|new|delete|catch|sizeof)\\b',\n                 fncall) and\n      # Ignore pointers/references to functions.\n      not Search(r' \\([^)]+\\)\\([^)]*(\\)|,$)', fncall) and\n      # Ignore pointers/references to arrays.\n      not Search(r' \\([^)]+\\)\\[[^\\]]+\\]', fncall)):\n    if Search(r'\\w\\s*\\(\\s(?!\\s*\\\\$)', fncall):      # a ( used for a fn call\n      error(filename, linenum, 'whitespace/parens', 4,\n            'Extra space after ( in function call')\n    elif Search(r'\\(\\s+(?!(\\s*\\\\)|\\()', fncall):\n      error(filename, linenum, 'whitespace/parens', 2,\n            'Extra space after (')\n    if (Search(r'\\w\\s+\\(', fncall) and\n        not Search(r'_{0,2}asm_{0,2}\\s+_{0,2}volatile_{0,2}\\s+\\(', fncall) and\n        not Search(r'#\\s*define|typedef|using\\s+\\w+\\s*=', fncall) and\n        not Search(r'\\w\\s+\\((\\w+::)*\\*\\w+\\)\\(', fncall) and\n        not Search(r'\\bcase\\s+\\(', fncall)):\n      # TODO(unknown): Space after an operator function seem to be a common\n      # error, silence those for now by restricting them to highest verbosity.\n      if Search(r'\\boperator_*\\b', line):\n        error(filename, linenum, 'whitespace/parens', 0,\n              'Extra space before ( in function call')\n      else:\n        error(filename, linenum, 'whitespace/parens', 4,\n              'Extra space before ( in function call')\n    # If the ) is followed only by a newline or a { + newline, assume it's\n    # part of a control statement (if/while/etc), and don't complain\n    if Search(r'[^)]\\s+\\)\\s*[^{\\s]', fncall):\n      # If the closing parenthesis is preceded by only whitespaces,\n      # try to give a more descriptive error message.\n      if Search(r'^\\s+\\)', fncall):\n        error(filename, linenum, 'whitespace/parens', 2,\n              'Closing ) should be moved to the previous line')\n      else:\n        error(filename, linenum, 'whitespace/parens', 2,\n              'Extra space before )')\n\n\ndef IsBlankLine(line):\n  \"\"\"Returns true if the given line is blank.\n\n  We consider a line to be blank if the line is empty or consists of\n  only white spaces.\n\n  Args:\n    line: A line of a string.\n\n  Returns:\n    True, if the given line is blank.\n  \"\"\"\n  return not line or line.isspace()\n\n\ndef CheckForNamespaceIndentation(filename, nesting_state, clean_lines, line,\n                                 error):\n  is_namespace_indent_item = (\n      len(nesting_state.stack) > 1 and\n      nesting_state.stack[-1].check_namespace_indentation and\n      isinstance(nesting_state.previous_stack_top, _NamespaceInfo) and\n      nesting_state.previous_stack_top == nesting_state.stack[-2])\n\n  if ShouldCheckNamespaceIndentation(nesting_state, is_namespace_indent_item,\n                                     clean_lines.elided, line):\n    CheckItemIndentationInNamespace(filename, clean_lines.elided,\n                                    line, error)\n\n\ndef CheckForFunctionLengths(filename, clean_lines, linenum,\n                            function_state, error):\n  \"\"\"Reports for long function bodies.\n\n  For an overview why this is done, see:\n  https://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Write_Short_Functions\n\n  Uses a simplistic algorithm assuming other style guidelines\n  (especially spacing) are followed.\n  Only checks unindented functions, so class members are unchecked.\n  Trivial bodies are unchecked, so constructors with huge initializer lists\n  may be missed.\n  Blank/comment lines are not counted so as to avoid encouraging the removal\n  of vertical space and comments just to get through a lint check.\n  NOLINT *on the last line of a function* disables this check.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    function_state: Current function name and lines in body so far.\n    error: The function to call with any errors found.\n  \"\"\"\n  lines = clean_lines.lines\n  line = lines[linenum]\n  joined_line = ''\n\n  starting_func = False\n  regexp = r'(\\w(\\w|::|\\*|\\&|\\s)*)\\('  # decls * & space::name( ...\n  match_result = Match(regexp, line)\n  if match_result:\n    # If the name is all caps and underscores, figure it's a macro and\n    # ignore it, unless it's TEST or TEST_F.\n    function_name = match_result.group(1).split()[-1]\n    if function_name == 'TEST' or function_name == 'TEST_F' or (\n        not Match(r'[A-Z_]+$', function_name)):\n      starting_func = True\n\n  if starting_func:\n    body_found = False\n    for start_linenum in range(linenum, clean_lines.NumLines()):\n      start_line = lines[start_linenum]\n      joined_line += ' ' + start_line.lstrip()\n      if Search(r'(;|})', start_line):  # Declarations and trivial functions\n        body_found = True\n        break                              # ... ignore\n      elif Search(r'{', start_line):\n        body_found = True\n        function = Search(r'((\\w|:)*)\\(', line).group(1)\n        if Match(r'TEST', function):    # Handle TEST... macros\n          parameter_regexp = Search(r'(\\(.*\\))', joined_line)\n          if parameter_regexp:             # Ignore bad syntax\n            function += parameter_regexp.group(1)\n        else:\n          function += '()'\n        function_state.Begin(function)\n        break\n    if not body_found:\n      # No body for the function (or evidence of a non-function) was found.\n      error(filename, linenum, 'readability/fn_size', 5,\n            'Lint failed to find start of function body.')\n  elif Match(r'^\\}\\s*$', line):  # function end\n    function_state.Check(error, filename, linenum)\n    function_state.End()\n  elif not Match(r'^\\s*$', line):\n    function_state.Count()  # Count non-blank/non-comment lines.\n\n\n_RE_PATTERN_TODO = re.compile(r'^//(\\s*)TODO(\\(.+?\\))?:?(\\s|$)?')\n\n\ndef CheckComment(line, filename, linenum, next_line_start, error):\n  \"\"\"Checks for common mistakes in comments.\n\n  Args:\n    line: The line in question.\n    filename: The name of the current file.\n    linenum: The number of the line to check.\n    next_line_start: The first non-whitespace column of the next line.\n    error: The function to call with any errors found.\n  \"\"\"\n  commentpos = line.find('//')\n  if commentpos != -1:\n    # Check if the // may be in quotes.  If so, ignore it\n    if re.sub(r'\\\\.', '', line[0:commentpos]).count('\"') % 2 == 0:\n      # Allow one space for new scopes, two spaces otherwise:\n      if (not (Match(r'^.*{ *//', line) and next_line_start == commentpos) and\n          ((commentpos >= 1 and\n            line[commentpos-1] not in string.whitespace) or\n           (commentpos >= 2 and\n            line[commentpos-2] not in string.whitespace))):\n        error(filename, linenum, 'whitespace/comments', 2,\n              'At least two spaces is best between code and comments')\n\n      # Checks for common mistakes in TODO comments.\n      comment = line[commentpos:]\n      match = _RE_PATTERN_TODO.match(comment)\n      if match:\n        # One whitespace is correct; zero whitespace is handled elsewhere.\n        leading_whitespace = match.group(1)\n        if len(leading_whitespace) > 1:\n          error(filename, linenum, 'whitespace/todo', 2,\n                'Too many spaces before TODO')\n\n        username = match.group(2)\n        if not username:\n          error(filename, linenum, 'readability/todo', 2,\n                'Missing username in TODO; it should look like '\n                '\"// TODO(my_username): Stuff.\"')\n\n        middle_whitespace = match.group(3)\n        # Comparisons made explicit for correctness -- pylint: disable=g-explicit-bool-comparison\n        if middle_whitespace != ' ' and middle_whitespace != '':\n          error(filename, linenum, 'whitespace/todo', 2,\n                'TODO(my_username) should be followed by a space')\n\n      # If the comment contains an alphanumeric character, there\n      # should be a space somewhere between it and the // unless\n      # it's a /// or //! Doxygen comment.\n      if (Match(r'//[^ ]*\\w', comment) and\n          not Match(r'(///|//\\!)(\\s+|$)', comment)):\n        error(filename, linenum, 'whitespace/comments', 4,\n              'Should have a space between // and comment')\n\n\ndef CheckAccess(filename, clean_lines, linenum, nesting_state, error):\n  \"\"\"Checks for improper use of DISALLOW* macros.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    nesting_state: A NestingState instance which maintains information about\n                   the current stack of nested blocks being parsed.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]  # get rid of comments and strings\n\n  matched = Match((r'\\s*(DISALLOW_COPY_AND_ASSIGN|'\n                   r'DISALLOW_IMPLICIT_CONSTRUCTORS)'), line)\n  if not matched:\n    return\n  if nesting_state.stack and isinstance(nesting_state.stack[-1], _ClassInfo):\n    if nesting_state.stack[-1].access != 'private':\n      error(filename, linenum, 'readability/constructors', 3,\n            '%s must be in the private: section' % matched.group(1))\n\n  else:\n    # Found DISALLOW* macro outside a class declaration, or perhaps it\n    # was used inside a function when it should have been part of the\n    # class declaration.  We could issue a warning here, but it\n    # probably resulted in a compiler error already.\n    pass\n\n\ndef CheckSpacing(filename, clean_lines, linenum, nesting_state, error):\n  \"\"\"Checks for the correctness of various spacing issues in the code.\n\n  Things we check for: spaces around operators, spaces after\n  if/for/while/switch, no spaces around parens in function calls, two\n  spaces between code and comment, don't start a block with a blank\n  line, don't end a function with a blank line, don't add a blank line\n  after public/protected/private, don't have too many blank lines in a row.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    nesting_state: A NestingState instance which maintains information about\n                   the current stack of nested blocks being parsed.\n    error: The function to call with any errors found.\n  \"\"\"\n\n  # Don't use \"elided\" lines here, otherwise we can't check commented lines.\n  # Don't want to use \"raw\" either, because we don't want to check inside C++11\n  # raw strings,\n  raw = clean_lines.lines_without_raw_strings\n  line = raw[linenum]\n\n  # Before nixing comments, check if the line is blank for no good\n  # reason.  This includes the first line after a block is opened, and\n  # blank lines at the end of a function (ie, right before a line like '}'\n  #\n  # Skip all the blank line checks if we are immediately inside a\n  # namespace body.  In other words, don't issue blank line warnings\n  # for this block:\n  #   namespace {\n  #\n  #   }\n  #\n  # A warning about missing end of namespace comments will be issued instead.\n  #\n  # Also skip blank line checks for 'extern \"C\"' blocks, which are formatted\n  # like namespaces.\n  if (IsBlankLine(line) and\n      not nesting_state.InNamespaceBody() and\n      not nesting_state.InExternC()):\n    elided = clean_lines.elided\n    prev_line = elided[linenum - 1]\n    prevbrace = prev_line.rfind('{')\n    # TODO(unknown): Don't complain if line before blank line, and line after,\n    #                both start with alnums and are indented the same amount.\n    #                This ignores whitespace at the start of a namespace block\n    #                because those are not usually indented.\n    if prevbrace != -1 and prev_line[prevbrace:].find('}') == -1:\n      # OK, we have a blank line at the start of a code block.  Before we\n      # complain, we check if it is an exception to the rule: The previous\n      # non-empty line has the parameters of a function header that are indented\n      # 4 spaces (because they did not fit in a 80 column line when placed on\n      # the same line as the function name).  We also check for the case where\n      # the previous line is indented 6 spaces, which may happen when the\n      # initializers of a constructor do not fit into a 80 column line.\n      exception = False\n      if Match(r' {6}\\w', prev_line):  # Initializer list?\n        # We are looking for the opening column of initializer list, which\n        # should be indented 4 spaces to cause 6 space indentation afterwards.\n        search_position = linenum-2\n        while (search_position >= 0\n               and Match(r' {6}\\w', elided[search_position])):\n          search_position -= 1\n        exception = (search_position >= 0\n                     and elided[search_position][:5] == '    :')\n      else:\n        # Search for the function arguments or an initializer list.  We use a\n        # simple heuristic here: If the line is indented 4 spaces; and we have a\n        # closing paren, without the opening paren, followed by an opening brace\n        # or colon (for initializer lists) we assume that it is the last line of\n        # a function header.  If we have a colon indented 4 spaces, it is an\n        # initializer list.\n        exception = (Match(r' {4}\\w[^\\(]*\\)\\s*(const\\s*)?(\\{\\s*$|:)',\n                           prev_line)\n                     or Match(r' {4}:', prev_line))\n\n      if not exception:\n        error(filename, linenum, 'whitespace/blank_line', 2,\n              'Redundant blank line at the start of a code block '\n              'should be deleted.')\n    # Ignore blank lines at the end of a block in a long if-else\n    # chain, like this:\n    #   if (condition1) {\n    #     // Something followed by a blank line\n    #\n    #   } else if (condition2) {\n    #     // Something else\n    #   }\n    if linenum + 1 < clean_lines.NumLines():\n      next_line = raw[linenum + 1]\n      if (next_line\n          and Match(r'\\s*}', next_line)\n          and next_line.find('} else ') == -1):\n        error(filename, linenum, 'whitespace/blank_line', 3,\n              'Redundant blank line at the end of a code block '\n              'should be deleted.')\n\n    matched = Match(r'\\s*(public|protected|private):', prev_line)\n    if matched:\n      error(filename, linenum, 'whitespace/blank_line', 3,\n            'Do not leave a blank line after \"%s:\"' % matched.group(1))\n\n  # Next, check comments\n  next_line_start = 0\n  if linenum + 1 < clean_lines.NumLines():\n    next_line = raw[linenum + 1]\n    next_line_start = len(next_line) - len(next_line.lstrip())\n  CheckComment(line, filename, linenum, next_line_start, error)\n\n  # get rid of comments and strings\n  line = clean_lines.elided[linenum]\n\n  # You shouldn't have spaces before your brackets, except maybe after\n  # 'delete []' or 'return []() {};'\n  if Search(r'\\w\\s+\\[', line) and not Search(r'(?:delete|return)\\s+\\[', line):\n    error(filename, linenum, 'whitespace/braces', 5,\n          'Extra space before [')\n\n  # In range-based for, we wanted spaces before and after the colon, but\n  # not around \"::\" tokens that might appear.\n  if (Search(r'for *\\(.*[^:]:[^: ]', line) or\n      Search(r'for *\\(.*[^: ]:[^:]', line)):\n    error(filename, linenum, 'whitespace/forcolon', 2,\n          'Missing space around colon in range-based for loop')\n\n\ndef CheckOperatorSpacing(filename, clean_lines, linenum, error):\n  \"\"\"Checks for horizontal spacing around operators.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n\n  # Don't try to do spacing checks for operator methods.  Do this by\n  # replacing the troublesome characters with something else,\n  # preserving column position for all other characters.\n  #\n  # The replacement is done repeatedly to avoid false positives from\n  # operators that call operators.\n  while True:\n    match = Match(r'^(.*\\boperator\\b)(\\S+)(\\s*\\(.*)$', line)\n    if match:\n      line = match.group(1) + ('_' * len(match.group(2))) + match.group(3)\n    else:\n      break\n\n  # We allow no-spaces around = within an if: \"if ( (a=Foo()) == 0 )\".\n  # Otherwise not.  Note we only check for non-spaces on *both* sides;\n  # sometimes people put non-spaces on one side when aligning ='s among\n  # many lines (not that this is behavior that I approve of...)\n  if ((Search(r'[\\w.]=', line) or\n       Search(r'=[\\w.]', line))\n      and not Search(r'\\b(if|while|for) ', line)\n      # Operators taken from [lex.operators] in C++11 standard.\n      and not Search(r'(>=|<=|==|!=|&=|\\^=|\\|=|\\+=|\\*=|\\/=|\\%=)', line)\n      and not Search(r'operator=', line)):\n    error(filename, linenum, 'whitespace/operators', 4,\n          'Missing spaces around =')\n\n  # It's ok not to have spaces around binary operators like + - * /, but if\n  # there's too little whitespace, we get concerned.  It's hard to tell,\n  # though, so we punt on this one for now.  TODO.\n\n  # You should always have whitespace around binary operators.\n  #\n  # Check <= and >= first to avoid false positives with < and >, then\n  # check non-include lines for spacing around < and >.\n  #\n  # If the operator is followed by a comma, assume it's be used in a\n  # macro context and don't do any checks.  This avoids false\n  # positives.\n  #\n  # Note that && is not included here.  This is because there are too\n  # many false positives due to RValue references.\n  match = Search(r'[^<>=!\\s](==|!=|<=|>=|\\|\\|)[^<>=!\\s,;\\)]', line)\n  if match:\n    error(filename, linenum, 'whitespace/operators', 3,\n          'Missing spaces around %s' % match.group(1))\n  elif not Match(r'#.*include', line):\n    # Look for < that is not surrounded by spaces.  This is only\n    # triggered if both sides are missing spaces, even though\n    # technically should should flag if at least one side is missing a\n    # space.  This is done to avoid some false positives with shifts.\n    match = Match(r'^(.*[^\\s<])<[^\\s=<,]', line)\n    if match:\n      (_, _, end_pos) = CloseExpression(\n          clean_lines, linenum, len(match.group(1)))\n      if end_pos <= -1:\n        error(filename, linenum, 'whitespace/operators', 3,\n              'Missing spaces around <')\n\n    # Look for > that is not surrounded by spaces.  Similar to the\n    # above, we only trigger if both sides are missing spaces to avoid\n    # false positives with shifts.\n    match = Match(r'^(.*[^-\\s>])>[^\\s=>,]', line)\n    if match:\n      (_, _, start_pos) = ReverseCloseExpression(\n          clean_lines, linenum, len(match.group(1)))\n      if start_pos <= -1:\n        error(filename, linenum, 'whitespace/operators', 3,\n              'Missing spaces around >')\n\n  # We allow no-spaces around << when used like this: 10<<20, but\n  # not otherwise (particularly, not when used as streams)\n  #\n  # We also allow operators following an opening parenthesis, since\n  # those tend to be macros that deal with operators.\n  match = Search(r'(operator|[^\\s(<])(?:L|UL|LL|ULL|l|ul|ll|ull)?<<([^\\s,=<])', line)\n  if (match and not (match.group(1).isdigit() and match.group(2).isdigit()) and\n      not (match.group(1) == 'operator' and match.group(2) == ';')):\n    error(filename, linenum, 'whitespace/operators', 3,\n          'Missing spaces around <<')\n\n  # We allow no-spaces around >> for almost anything.  This is because\n  # C++11 allows \">>\" to close nested templates, which accounts for\n  # most cases when \">>\" is not followed by a space.\n  #\n  # We still warn on \">>\" followed by alpha character, because that is\n  # likely due to \">>\" being used for right shifts, e.g.:\n  #   value >> alpha\n  #\n  # When \">>\" is used to close templates, the alphanumeric letter that\n  # follows would be part of an identifier, and there should still be\n  # a space separating the template type and the identifier.\n  #   type<type<type>> alpha\n  match = Search(r'>>[a-zA-Z_]', line)\n  if match:\n    error(filename, linenum, 'whitespace/operators', 3,\n          'Missing spaces around >>')\n\n  # There shouldn't be space around unary operators\n  match = Search(r'(!\\s|~\\s|[\\s]--[\\s;]|[\\s]\\+\\+[\\s;])', line)\n  if match:\n    error(filename, linenum, 'whitespace/operators', 4,\n          'Extra space for operator %s' % match.group(1))\n\n\ndef CheckParenthesisSpacing(filename, clean_lines, linenum, error):\n  \"\"\"Checks for horizontal spacing around parentheses.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n\n  # No spaces after an if, while, switch, or for\n  match = Search(r' (if\\(|for\\(|while\\(|switch\\()', line)\n  if match:\n    error(filename, linenum, 'whitespace/parens', 5,\n          'Missing space before ( in %s' % match.group(1))\n\n  # For if/for/while/switch, the left and right parens should be\n  # consistent about how many spaces are inside the parens, and\n  # there should either be zero or one spaces inside the parens.\n  # We don't want: \"if ( foo)\" or \"if ( foo   )\".\n  # Exception: \"for ( ; foo; bar)\" and \"for (foo; bar; )\" are allowed.\n  match = Search(r'\\b(if|for|while|switch)\\s*'\n                 r'\\(([ ]*)(.).*[^ ]+([ ]*)\\)\\s*{\\s*$',\n                 line)\n  if match:\n    if len(match.group(2)) != len(match.group(4)):\n      if not (match.group(3) == ';' and\n              len(match.group(2)) == 1 + len(match.group(4)) or\n              not match.group(2) and Search(r'\\bfor\\s*\\(.*; \\)', line)):\n        error(filename, linenum, 'whitespace/parens', 5,\n              'Mismatching spaces inside () in %s' % match.group(1))\n    if len(match.group(2)) not in [0, 1]:\n      error(filename, linenum, 'whitespace/parens', 5,\n            'Should have zero or one spaces inside ( and ) in %s' %\n            match.group(1))\n\n\ndef CheckCommaSpacing(filename, clean_lines, linenum, error):\n  \"\"\"Checks for horizontal spacing near commas and semicolons.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  raw = clean_lines.lines_without_raw_strings\n  line = clean_lines.elided[linenum]\n\n  # You should always have a space after a comma (either as fn arg or operator)\n  #\n  # This does not apply when the non-space character following the\n  # comma is another comma, since the only time when that happens is\n  # for empty macro arguments.\n  #\n  # We run this check in two passes: first pass on elided lines to\n  # verify that lines contain missing whitespaces, second pass on raw\n  # lines to confirm that those missing whitespaces are not due to\n  # elided comments.\n  if (Search(r',[^,\\s]', ReplaceAll(r'\\boperator\\s*,\\s*\\(', 'F(', line)) and\n      Search(r',[^,\\s]', raw[linenum])):\n    error(filename, linenum, 'whitespace/comma', 3,\n          'Missing space after ,')\n\n  # You should always have a space after a semicolon\n  # except for few corner cases\n  # TODO(unknown): clarify if 'if (1) { return 1;}' is requires one more\n  # space after ;\n  if Search(r';[^\\s};\\\\)/]', line):\n    error(filename, linenum, 'whitespace/semicolon', 3,\n          'Missing space after ;')\n\n\ndef _IsType(clean_lines, nesting_state, expr):\n  \"\"\"Check if expression looks like a type name, returns true if so.\n\n  Args:\n    clean_lines: A CleansedLines instance containing the file.\n    nesting_state: A NestingState instance which maintains information about\n                   the current stack of nested blocks being parsed.\n    expr: The expression to check.\n  Returns:\n    True, if token looks like a type.\n  \"\"\"\n  # Keep only the last token in the expression\n  last_word = Match(r'^.*(\\b\\S+)$', expr)\n  if last_word:\n    token = last_word.group(1)\n  else:\n    token = expr\n\n  # Match native types and stdint types\n  if _TYPES.match(token):\n    return True\n\n  # Try a bit harder to match templated types.  Walk up the nesting\n  # stack until we find something that resembles a typename\n  # declaration for what we are looking for.\n  typename_pattern = (r'\\b(?:typename|class|struct)\\s+' + re.escape(token) +\n                      r'\\b')\n  block_index = len(nesting_state.stack) - 1\n  while block_index >= 0:\n    if isinstance(nesting_state.stack[block_index], _NamespaceInfo):\n      return False\n\n    # Found where the opening brace is.  We want to scan from this\n    # line up to the beginning of the function, minus a few lines.\n    #   template <typename Type1,  // stop scanning here\n    #             ...>\n    #   class C\n    #     : public ... {  // start scanning here\n    last_line = nesting_state.stack[block_index].starting_linenum\n\n    next_block_start = 0\n    if block_index > 0:\n      next_block_start = nesting_state.stack[block_index - 1].starting_linenum\n    first_line = last_line\n    while first_line >= next_block_start:\n      if clean_lines.elided[first_line].find('template') >= 0:\n        break\n      first_line -= 1\n    if first_line < next_block_start:\n      # Didn't find any \"template\" keyword before reaching the next block,\n      # there are probably no template things to check for this block\n      block_index -= 1\n      continue\n\n    # Look for typename in the specified range\n    for i in xrange(first_line, last_line + 1, 1):\n      if Search(typename_pattern, clean_lines.elided[i]):\n        return True\n    block_index -= 1\n\n  return False\n\n\ndef CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error):\n  \"\"\"Checks for horizontal spacing near commas.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    nesting_state: A NestingState instance which maintains information about\n                   the current stack of nested blocks being parsed.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n\n  # Except after an opening paren, or after another opening brace (in case of\n  # an initializer list, for instance), you should have spaces before your\n  # braces when they are delimiting blocks, classes, namespaces etc.\n  # And since you should never have braces at the beginning of a line,\n  # this is an easy test.  Except that braces used for initialization don't\n  # follow the same rule; we often don't want spaces before those.\n  match = Match(r'^(.*[^ ({>]){', line)\n\n  if match:\n    # Try a bit harder to check for brace initialization.  This\n    # happens in one of the following forms:\n    #   Constructor() : initializer_list_{} { ... }\n    #   Constructor{}.MemberFunction()\n    #   Type variable{};\n    #   FunctionCall(type{}, ...);\n    #   LastArgument(..., type{});\n    #   LOG(INFO) << type{} << \" ...\";\n    #   map_of_type[{...}] = ...;\n    #   ternary = expr ? new type{} : nullptr;\n    #   OuterTemplate<InnerTemplateConstructor<Type>{}>\n    #\n    # We check for the character following the closing brace, and\n    # silence the warning if it's one of those listed above, i.e.\n    # \"{.;,)<>]:\".\n    #\n    # To account for nested initializer list, we allow any number of\n    # closing braces up to \"{;,)<\".  We can't simply silence the\n    # warning on first sight of closing brace, because that would\n    # cause false negatives for things that are not initializer lists.\n    #   Silence this:         But not this:\n    #     Outer{                if (...) {\n    #       Inner{...}            if (...){  // Missing space before {\n    #     };                    }\n    #\n    # There is a false negative with this approach if people inserted\n    # spurious semicolons, e.g. \"if (cond){};\", but we will catch the\n    # spurious semicolon with a separate check.\n    leading_text = match.group(1)\n    (endline, endlinenum, endpos) = CloseExpression(\n        clean_lines, linenum, len(match.group(1)))\n    trailing_text = ''\n    if endpos > -1:\n      trailing_text = endline[endpos:]\n    for offset in xrange(endlinenum + 1,\n                         min(endlinenum + 3, clean_lines.NumLines() - 1)):\n      trailing_text += clean_lines.elided[offset]\n    # We also suppress warnings for `uint64_t{expression}` etc., as the style\n    # guide recommends brace initialization for integral types to avoid\n    # overflow/truncation.\n    if (not Match(r'^[\\s}]*[{.;,)<>\\]:]', trailing_text)\n        and not _IsType(clean_lines, nesting_state, leading_text)):\n      error(filename, linenum, 'whitespace/braces', 5,\n            'Missing space before {')\n\n  # Make sure '} else {' has spaces.\n  if Search(r'}else', line):\n    error(filename, linenum, 'whitespace/braces', 5,\n          'Missing space before else')\n\n  # You shouldn't have a space before a semicolon at the end of the line.\n  # There's a special case for \"for\" since the style guide allows space before\n  # the semicolon there.\n  if Search(r':\\s*;\\s*$', line):\n    error(filename, linenum, 'whitespace/semicolon', 5,\n          'Semicolon defining empty statement. Use {} instead.')\n  elif Search(r'^\\s*;\\s*$', line):\n    error(filename, linenum, 'whitespace/semicolon', 5,\n          'Line contains only semicolon. If this should be an empty statement, '\n          'use {} instead.')\n  elif (Search(r'\\s+;\\s*$', line) and\n        not Search(r'\\bfor\\b', line)):\n    error(filename, linenum, 'whitespace/semicolon', 5,\n          'Extra space before last semicolon. If this should be an empty '\n          'statement, use {} instead.')\n\n\ndef IsDecltype(clean_lines, linenum, column):\n  \"\"\"Check if the token ending on (linenum, column) is decltype().\n\n  Args:\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: the number of the line to check.\n    column: end column of the token to check.\n  Returns:\n    True if this token is decltype() expression, False otherwise.\n  \"\"\"\n  (text, _, start_col) = ReverseCloseExpression(clean_lines, linenum, column)\n  if start_col < 0:\n    return False\n  if Search(r'\\bdecltype\\s*$', text[0:start_col]):\n    return True\n  return False\n\ndef CheckSectionSpacing(filename, clean_lines, class_info, linenum, error):\n  \"\"\"Checks for additional blank line issues related to sections.\n\n  Currently the only thing checked here is blank line before protected/private.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    class_info: A _ClassInfo objects.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  # Skip checks if the class is small, where small means 25 lines or less.\n  # 25 lines seems like a good cutoff since that's the usual height of\n  # terminals, and any class that can't fit in one screen can't really\n  # be considered \"small\".\n  #\n  # Also skip checks if we are on the first line.  This accounts for\n  # classes that look like\n  #   class Foo { public: ... };\n  #\n  # If we didn't find the end of the class, last_line would be zero,\n  # and the check will be skipped by the first condition.\n  if (class_info.last_line - class_info.starting_linenum <= 24 or\n      linenum <= class_info.starting_linenum):\n    return\n\n  matched = Match(r'\\s*(public|protected|private):', clean_lines.lines[linenum])\n  if matched:\n    # Issue warning if the line before public/protected/private was\n    # not a blank line, but don't do this if the previous line contains\n    # \"class\" or \"struct\".  This can happen two ways:\n    #  - We are at the beginning of the class.\n    #  - We are forward-declaring an inner class that is semantically\n    #    private, but needed to be public for implementation reasons.\n    # Also ignores cases where the previous line ends with a backslash as can be\n    # common when defining classes in C macros.\n    prev_line = clean_lines.lines[linenum - 1]\n    if (not IsBlankLine(prev_line) and\n        not Search(r'\\b(class|struct)\\b', prev_line) and\n        not Search(r'\\\\$', prev_line)):\n      # Try a bit harder to find the beginning of the class.  This is to\n      # account for multi-line base-specifier lists, e.g.:\n      #   class Derived\n      #       : public Base {\n      end_class_head = class_info.starting_linenum\n      for i in range(class_info.starting_linenum, linenum):\n        if Search(r'\\{\\s*$', clean_lines.lines[i]):\n          end_class_head = i\n          break\n      if end_class_head < linenum - 1:\n        error(filename, linenum, 'whitespace/blank_line', 3,\n              '\"%s:\" should be preceded by a blank line' % matched.group(1))\n\n\ndef GetPreviousNonBlankLine(clean_lines, linenum):\n  \"\"\"Return the most recent non-blank line and its line number.\n\n  Args:\n    clean_lines: A CleansedLines instance containing the file contents.\n    linenum: The number of the line to check.\n\n  Returns:\n    A tuple with two elements.  The first element is the contents of the last\n    non-blank line before the current line, or the empty string if this is the\n    first non-blank line.  The second is the line number of that line, or -1\n    if this is the first non-blank line.\n  \"\"\"\n\n  prevlinenum = linenum - 1\n  while prevlinenum >= 0:\n    prevline = clean_lines.elided[prevlinenum]\n    if not IsBlankLine(prevline):     # if not a blank line...\n      return (prevline, prevlinenum)\n    prevlinenum -= 1\n  return ('', -1)\n\n\ndef CheckBraces(filename, clean_lines, linenum, error):\n  \"\"\"Looks for misplaced braces (e.g. at the end of line).\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n\n  line = clean_lines.elided[linenum]        # get rid of comments and strings\n\n  if Match(r'\\s*{\\s*$', line):\n    # We allow an open brace to start a line in the case where someone is using\n    # braces in a block to explicitly create a new scope, which is commonly used\n    # to control the lifetime of stack-allocated variables.  Braces are also\n    # used for brace initializers inside function calls.  We don't detect this\n    # perfectly: we just don't complain if the last non-whitespace character on\n    # the previous non-blank line is ',', ';', ':', '(', '{', or '}', or if the\n    # previous line starts a preprocessor block. We also allow a brace on the\n    # following line if it is part of an array initialization and would not fit\n    # within the 80 character limit of the preceding line.\n    prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]\n    if (not Search(r'[,;:}{(]\\s*$', prevline) and\n        not Match(r'\\s*#', prevline) and\n        not (GetLineWidth(prevline) > _line_length - 2 and '[]' in prevline)):\n      error(filename, linenum, 'whitespace/braces', 4,\n            '{ should almost always be at the end of the previous line')\n\n  # An else clause should be on the same line as the preceding closing brace.\n  if Match(r'\\s*else\\b\\s*(?:if\\b|\\{|$)', line):\n    prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]\n    if Match(r'\\s*}\\s*$', prevline):\n      error(filename, linenum, 'whitespace/newline', 4,\n            'An else should appear on the same line as the preceding }')\n\n  # If braces come on one side of an else, they should be on both.\n  # However, we have to worry about \"else if\" that spans multiple lines!\n  if Search(r'else if\\s*\\(', line):       # could be multi-line if\n    brace_on_left = bool(Search(r'}\\s*else if\\s*\\(', line))\n    # find the ( after the if\n    pos = line.find('else if')\n    pos = line.find('(', pos)\n    if pos > 0:\n      (endline, _, endpos) = CloseExpression(clean_lines, linenum, pos)\n      brace_on_right = endline[endpos:].find('{') != -1\n      if brace_on_left != brace_on_right:    # must be brace after if\n        error(filename, linenum, 'readability/braces', 5,\n              'If an else has a brace on one side, it should have it on both')\n  elif Search(r'}\\s*else[^{]*$', line) or Match(r'[^}]*else\\s*{', line):\n    error(filename, linenum, 'readability/braces', 5,\n          'If an else has a brace on one side, it should have it on both')\n\n  # Likewise, an else should never have the else clause on the same line\n  if Search(r'\\belse [^\\s{]', line) and not Search(r'\\belse if\\b', line):\n    error(filename, linenum, 'whitespace/newline', 4,\n          'Else clause should never be on same line as else (use 2 lines)')\n\n  # In the same way, a do/while should never be on one line\n  if Match(r'\\s*do [^\\s{]', line):\n    error(filename, linenum, 'whitespace/newline', 4,\n          'do/while clauses should not be on a single line')\n\n  # Check single-line if/else bodies. The style guide says 'curly braces are not\n  # required for single-line statements'. We additionally allow multi-line,\n  # single statements, but we reject anything with more than one semicolon in\n  # it. This means that the first semicolon after the if should be at the end of\n  # its line, and the line after that should have an indent level equal to or\n  # lower than the if. We also check for ambiguous if/else nesting without\n  # braces.\n  if_else_match = Search(r'\\b(if\\s*\\(|else\\b)', line)\n  if if_else_match and not Match(r'\\s*#', line):\n    if_indent = GetIndentLevel(line)\n    endline, endlinenum, endpos = line, linenum, if_else_match.end()\n    if_match = Search(r'\\bif\\s*\\(', line)\n    if if_match:\n      # This could be a multiline if condition, so find the end first.\n      pos = if_match.end() - 1\n      (endline, endlinenum, endpos) = CloseExpression(clean_lines, linenum, pos)\n    # Check for an opening brace, either directly after the if or on the next\n    # line. If found, this isn't a single-statement conditional.\n    if (not Match(r'\\s*{', endline[endpos:])\n        and not (Match(r'\\s*$', endline[endpos:])\n                 and endlinenum < (len(clean_lines.elided) - 1)\n                 and Match(r'\\s*{', clean_lines.elided[endlinenum + 1]))):\n      while (endlinenum < len(clean_lines.elided)\n             and ';' not in clean_lines.elided[endlinenum][endpos:]):\n        endlinenum += 1\n        endpos = 0\n      if endlinenum < len(clean_lines.elided):\n        endline = clean_lines.elided[endlinenum]\n        # We allow a mix of whitespace and closing braces (e.g. for one-liner\n        # methods) and a single \\ after the semicolon (for macros)\n        endpos = endline.find(';')\n        if not Match(r';[\\s}]*(\\\\?)$', endline[endpos:]):\n          # Semicolon isn't the last character, there's something trailing.\n          # Output a warning if the semicolon is not contained inside\n          # a lambda expression.\n          if not Match(r'^[^{};]*\\[[^\\[\\]]*\\][^{}]*\\{[^{}]*\\}\\s*\\)*[;,]\\s*$',\n                       endline):\n            error(filename, linenum, 'readability/braces', 4,\n                  'If/else bodies with multiple statements require braces')\n        elif endlinenum < len(clean_lines.elided) - 1:\n          # Make sure the next line is dedented\n          next_line = clean_lines.elided[endlinenum + 1]\n          next_indent = GetIndentLevel(next_line)\n          # With ambiguous nested if statements, this will error out on the\n          # if that *doesn't* match the else, regardless of whether it's the\n          # inner one or outer one.\n          if (if_match and Match(r'\\s*else\\b', next_line)\n              and next_indent != if_indent):\n            error(filename, linenum, 'readability/braces', 4,\n                  'Else clause should be indented at the same level as if. '\n                  'Ambiguous nested if/else chains require braces.')\n          elif next_indent > if_indent:\n            error(filename, linenum, 'readability/braces', 4,\n                  'If/else bodies with multiple statements require braces')\n\n\ndef CheckTrailingSemicolon(filename, clean_lines, linenum, error):\n  \"\"\"Looks for redundant trailing semicolon.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n\n  line = clean_lines.elided[linenum]\n\n  # Block bodies should not be followed by a semicolon.  Due to C++11\n  # brace initialization, there are more places where semicolons are\n  # required than not, so we use a whitelist approach to check these\n  # rather than a blacklist.  These are the places where \"};\" should\n  # be replaced by just \"}\":\n  # 1. Some flavor of block following closing parenthesis:\n  #    for (;;) {};\n  #    while (...) {};\n  #    switch (...) {};\n  #    Function(...) {};\n  #    if (...) {};\n  #    if (...) else if (...) {};\n  #\n  # 2. else block:\n  #    if (...) else {};\n  #\n  # 3. const member function:\n  #    Function(...) const {};\n  #\n  # 4. Block following some statement:\n  #    x = 42;\n  #    {};\n  #\n  # 5. Block at the beginning of a function:\n  #    Function(...) {\n  #      {};\n  #    }\n  #\n  #    Note that naively checking for the preceding \"{\" will also match\n  #    braces inside multi-dimensional arrays, but this is fine since\n  #    that expression will not contain semicolons.\n  #\n  # 6. Block following another block:\n  #    while (true) {}\n  #    {};\n  #\n  # 7. End of namespaces:\n  #    namespace {};\n  #\n  #    These semicolons seems far more common than other kinds of\n  #    redundant semicolons, possibly due to people converting classes\n  #    to namespaces.  For now we do not warn for this case.\n  #\n  # Try matching case 1 first.\n  match = Match(r'^(.*\\)\\s*)\\{', line)\n  if match:\n    # Matched closing parenthesis (case 1).  Check the token before the\n    # matching opening parenthesis, and don't warn if it looks like a\n    # macro.  This avoids these false positives:\n    #  - macro that defines a base class\n    #  - multi-line macro that defines a base class\n    #  - macro that defines the whole class-head\n    #\n    # But we still issue warnings for macros that we know are safe to\n    # warn, specifically:\n    #  - TEST, TEST_F, TEST_P, MATCHER, MATCHER_P\n    #  - TYPED_TEST\n    #  - INTERFACE_DEF\n    #  - EXCLUSIVE_LOCKS_REQUIRED, SHARED_LOCKS_REQUIRED, LOCKS_EXCLUDED:\n    #\n    # We implement a whitelist of safe macros instead of a blacklist of\n    # unsafe macros, even though the latter appears less frequently in\n    # google code and would have been easier to implement.  This is because\n    # the downside for getting the whitelist wrong means some extra\n    # semicolons, while the downside for getting the blacklist wrong\n    # would result in compile errors.\n    #\n    # In addition to macros, we also don't want to warn on\n    #  - Compound literals\n    #  - Lambdas\n    #  - alignas specifier with anonymous structs\n    #  - decltype\n    closing_brace_pos = match.group(1).rfind(')')\n    opening_parenthesis = ReverseCloseExpression(\n        clean_lines, linenum, closing_brace_pos)\n    if opening_parenthesis[2] > -1:\n      line_prefix = opening_parenthesis[0][0:opening_parenthesis[2]]\n      macro = Search(r'\\b([A-Z_][A-Z0-9_]*)\\s*$', line_prefix)\n      func = Match(r'^(.*\\])\\s*$', line_prefix)\n      if ((macro and\n           macro.group(1) not in (\n               'TEST', 'TEST_F', 'MATCHER', 'MATCHER_P', 'TYPED_TEST',\n               'EXCLUSIVE_LOCKS_REQUIRED', 'SHARED_LOCKS_REQUIRED',\n               'LOCKS_EXCLUDED', 'INTERFACE_DEF')) or\n          (func and not Search(r'\\boperator\\s*\\[\\s*\\]', func.group(1))) or\n          Search(r'\\b(?:struct|union)\\s+alignas\\s*$', line_prefix) or\n          Search(r'\\bdecltype$', line_prefix) or\n          Search(r'\\breturn\\s*$', line_prefix) or\n          Search(r'\\s+=\\s*$', line_prefix)):\n        match = None\n    if (match and\n        opening_parenthesis[1] > 1 and\n        Search(r'\\]\\s*$', clean_lines.elided[opening_parenthesis[1] - 1])):\n      # Multi-line lambda-expression\n      match = None\n\n  else:\n    # Try matching cases 2-3.\n    match = Match(r'^(.*(?:else|\\)\\s*const)\\s*)\\{', line)\n    if not match:\n      # Try matching cases 4-6.  These are always matched on separate lines.\n      #\n      # Note that we can't simply concatenate the previous line to the\n      # current line and do a single match, otherwise we may output\n      # duplicate warnings for the blank line case:\n      #   if (cond) {\n      #     // blank line\n      #   }\n      prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]\n      if prevline and Search(r'[;{}]\\s*$', prevline):\n        match = Match(r'^(\\s*)\\{', line)\n\n  # Check matching closing brace\n  if match:\n    (endline, endlinenum, endpos) = CloseExpression(\n        clean_lines, linenum, len(match.group(1)))\n    if endpos > -1 and Match(r'^\\s*;', endline[endpos:]):\n      # Current {} pair is eligible for semicolon check, and we have found\n      # the redundant semicolon, output warning here.\n      #\n      # Note: because we are scanning forward for opening braces, and\n      # outputting warnings for the matching closing brace, if there are\n      # nested blocks with trailing semicolons, we will get the error\n      # messages in reversed order.\n\n      # We need to check the line forward for NOLINT\n      raw_lines = clean_lines.raw_lines\n      ParseNolintSuppressions(filename, raw_lines[endlinenum-1], endlinenum-1,\n                              error)\n      ParseNolintSuppressions(filename, raw_lines[endlinenum], endlinenum,\n                              error)\n\n      error(filename, endlinenum, 'readability/braces', 4,\n            \"You don't need a ; after a }\")\n\n\ndef CheckEmptyBlockBody(filename, clean_lines, linenum, error):\n  \"\"\"Look for empty loop/conditional body with only a single semicolon.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n\n  # Search for loop keywords at the beginning of the line.  Because only\n  # whitespaces are allowed before the keywords, this will also ignore most\n  # do-while-loops, since those lines should start with closing brace.\n  #\n  # We also check \"if\" blocks here, since an empty conditional block\n  # is likely an error.\n  line = clean_lines.elided[linenum]\n  matched = Match(r'\\s*(for|while|if)\\s*\\(', line)\n  if matched:\n    # Find the end of the conditional expression.\n    (end_line, end_linenum, end_pos) = CloseExpression(\n        clean_lines, linenum, line.find('('))\n\n    # Output warning if what follows the condition expression is a semicolon.\n    # No warning for all other cases, including whitespace or newline, since we\n    # have a separate check for semicolons preceded by whitespace.\n    if end_pos >= 0 and Match(r';', end_line[end_pos:]):\n      if matched.group(1) == 'if':\n        error(filename, end_linenum, 'whitespace/empty_conditional_body', 5,\n              'Empty conditional bodies should use {}')\n      else:\n        error(filename, end_linenum, 'whitespace/empty_loop_body', 5,\n              'Empty loop bodies should use {} or continue')\n\n    # Check for if statements that have completely empty bodies (no comments)\n    # and no else clauses.\n    if end_pos >= 0 and matched.group(1) == 'if':\n      # Find the position of the opening { for the if statement.\n      # Return without logging an error if it has no brackets.\n      opening_linenum = end_linenum\n      opening_line_fragment = end_line[end_pos:]\n      # Loop until EOF or find anything that's not whitespace or opening {.\n      while not Search(r'^\\s*\\{', opening_line_fragment):\n        if Search(r'^(?!\\s*$)', opening_line_fragment):\n          # Conditional has no brackets.\n          return\n        opening_linenum += 1\n        if opening_linenum == len(clean_lines.elided):\n          # Couldn't find conditional's opening { or any code before EOF.\n          return\n        opening_line_fragment = clean_lines.elided[opening_linenum]\n      # Set opening_line (opening_line_fragment may not be entire opening line).\n      opening_line = clean_lines.elided[opening_linenum]\n\n      # Find the position of the closing }.\n      opening_pos = opening_line_fragment.find('{')\n      if opening_linenum == end_linenum:\n        # We need to make opening_pos relative to the start of the entire line.\n        opening_pos += end_pos\n      (closing_line, closing_linenum, closing_pos) = CloseExpression(\n          clean_lines, opening_linenum, opening_pos)\n      if closing_pos < 0:\n        return\n\n      # Now construct the body of the conditional. This consists of the portion\n      # of the opening line after the {, all lines until the closing line,\n      # and the portion of the closing line before the }.\n      if (clean_lines.raw_lines[opening_linenum] !=\n          CleanseComments(clean_lines.raw_lines[opening_linenum])):\n        # Opening line ends with a comment, so conditional isn't empty.\n        return\n      if closing_linenum > opening_linenum:\n        # Opening line after the {. Ignore comments here since we checked above.\n        bodylist = list(opening_line[opening_pos+1:])\n        # All lines until closing line, excluding closing line, with comments.\n        bodylist.extend(clean_lines.raw_lines[opening_linenum+1:closing_linenum])\n        # Closing line before the }. Won't (and can't) have comments.\n        bodylist.append(clean_lines.elided[closing_linenum][:closing_pos-1])\n        body = '\\n'.join(bodylist)\n      else:\n        # If statement has brackets and fits on a single line.\n        body = opening_line[opening_pos+1:closing_pos-1]\n\n      # Check if the body is empty\n      if not _EMPTY_CONDITIONAL_BODY_PATTERN.search(body):\n        return\n      # The body is empty. Now make sure there's not an else clause.\n      current_linenum = closing_linenum\n      current_line_fragment = closing_line[closing_pos:]\n      # Loop until EOF or find anything that's not whitespace or else clause.\n      while Search(r'^\\s*$|^(?=\\s*else)', current_line_fragment):\n        if Search(r'^(?=\\s*else)', current_line_fragment):\n          # Found an else clause, so don't log an error.\n          return\n        current_linenum += 1\n        if current_linenum == len(clean_lines.elided):\n          break\n        current_line_fragment = clean_lines.elided[current_linenum]\n\n      # The body is empty and there's no else clause until EOF or other code.\n      error(filename, end_linenum, 'whitespace/empty_if_body', 4,\n            ('If statement had no body and no else clause'))\n\n\ndef FindCheckMacro(line):\n  \"\"\"Find a replaceable CHECK-like macro.\n\n  Args:\n    line: line to search on.\n  Returns:\n    (macro name, start position), or (None, -1) if no replaceable\n    macro is found.\n  \"\"\"\n  for macro in _CHECK_MACROS:\n    i = line.find(macro)\n    if i >= 0:\n      # Find opening parenthesis.  Do a regular expression match here\n      # to make sure that we are matching the expected CHECK macro, as\n      # opposed to some other macro that happens to contain the CHECK\n      # substring.\n      matched = Match(r'^(.*\\b' + macro + r'\\s*)\\(', line)\n      if not matched:\n        continue\n      return (macro, len(matched.group(1)))\n  return (None, -1)\n\n\ndef CheckCheck(filename, clean_lines, linenum, error):\n  \"\"\"Checks the use of CHECK and EXPECT macros.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n\n  # Decide the set of replacement macros that should be suggested\n  lines = clean_lines.elided\n  (check_macro, start_pos) = FindCheckMacro(lines[linenum])\n  if not check_macro:\n    return\n\n  # Find end of the boolean expression by matching parentheses\n  (last_line, end_line, end_pos) = CloseExpression(\n      clean_lines, linenum, start_pos)\n  if end_pos < 0:\n    return\n\n  # If the check macro is followed by something other than a\n  # semicolon, assume users will log their own custom error messages\n  # and don't suggest any replacements.\n  if not Match(r'\\s*;', last_line[end_pos:]):\n    return\n\n  if linenum == end_line:\n    expression = lines[linenum][start_pos + 1:end_pos - 1]\n  else:\n    expression = lines[linenum][start_pos + 1:]\n    for i in xrange(linenum + 1, end_line):\n      expression += lines[i]\n    expression += last_line[0:end_pos - 1]\n\n  # Parse expression so that we can take parentheses into account.\n  # This avoids false positives for inputs like \"CHECK((a < 4) == b)\",\n  # which is not replaceable by CHECK_LE.\n  lhs = ''\n  rhs = ''\n  operator = None\n  while expression:\n    matched = Match(r'^\\s*(<<|<<=|>>|>>=|->\\*|->|&&|\\|\\||'\n                    r'==|!=|>=|>|<=|<|\\()(.*)$', expression)\n    if matched:\n      token = matched.group(1)\n      if token == '(':\n        # Parenthesized operand\n        expression = matched.group(2)\n        (end, _) = FindEndOfExpressionInLine(expression, 0, ['('])\n        if end < 0:\n          return  # Unmatched parenthesis\n        lhs += '(' + expression[0:end]\n        expression = expression[end:]\n      elif token in ('&&', '||'):\n        # Logical and/or operators.  This means the expression\n        # contains more than one term, for example:\n        #   CHECK(42 < a && a < b);\n        #\n        # These are not replaceable with CHECK_LE, so bail out early.\n        return\n      elif token in ('<<', '<<=', '>>', '>>=', '->*', '->'):\n        # Non-relational operator\n        lhs += token\n        expression = matched.group(2)\n      else:\n        # Relational operator\n        operator = token\n        rhs = matched.group(2)\n        break\n    else:\n      # Unparenthesized operand.  Instead of appending to lhs one character\n      # at a time, we do another regular expression match to consume several\n      # characters at once if possible.  Trivial benchmark shows that this\n      # is more efficient when the operands are longer than a single\n      # character, which is generally the case.\n      matched = Match(r'^([^-=!<>()&|]+)(.*)$', expression)\n      if not matched:\n        matched = Match(r'^(\\s*\\S)(.*)$', expression)\n        if not matched:\n          break\n      lhs += matched.group(1)\n      expression = matched.group(2)\n\n  # Only apply checks if we got all parts of the boolean expression\n  if not (lhs and operator and rhs):\n    return\n\n  # Check that rhs do not contain logical operators.  We already know\n  # that lhs is fine since the loop above parses out && and ||.\n  if rhs.find('&&') > -1 or rhs.find('||') > -1:\n    return\n\n  # At least one of the operands must be a constant literal.  This is\n  # to avoid suggesting replacements for unprintable things like\n  # CHECK(variable != iterator)\n  #\n  # The following pattern matches decimal, hex integers, strings, and\n  # characters (in that order).\n  lhs = lhs.strip()\n  rhs = rhs.strip()\n  match_constant = r'^([-+]?(\\d+|0[xX][0-9a-fA-F]+)[lLuU]{0,3}|\".*\"|\\'.*\\')$'\n  if Match(match_constant, lhs) or Match(match_constant, rhs):\n    # Note: since we know both lhs and rhs, we can provide a more\n    # descriptive error message like:\n    #   Consider using CHECK_EQ(x, 42) instead of CHECK(x == 42)\n    # Instead of:\n    #   Consider using CHECK_EQ instead of CHECK(a == b)\n    #\n    # We are still keeping the less descriptive message because if lhs\n    # or rhs gets long, the error message might become unreadable.\n    error(filename, linenum, 'readability/check', 2,\n          'Consider using %s instead of %s(a %s b)' % (\n              _CHECK_REPLACEMENT[check_macro][operator],\n              check_macro, operator))\n\n\ndef CheckAltTokens(filename, clean_lines, linenum, error):\n  \"\"\"Check alternative keywords being used in boolean expressions.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n\n  # Avoid preprocessor lines\n  if Match(r'^\\s*#', line):\n    return\n\n  # Last ditch effort to avoid multi-line comments.  This will not help\n  # if the comment started before the current line or ended after the\n  # current line, but it catches most of the false positives.  At least,\n  # it provides a way to workaround this warning for people who use\n  # multi-line comments in preprocessor macros.\n  #\n  # TODO(unknown): remove this once cpplint has better support for\n  # multi-line comments.\n  if line.find('/*') >= 0 or line.find('*/') >= 0:\n    return\n\n  for match in _ALT_TOKEN_REPLACEMENT_PATTERN.finditer(line):\n    error(filename, linenum, 'readability/alt_tokens', 2,\n          'Use operator %s instead of %s' % (\n              _ALT_TOKEN_REPLACEMENT[match.group(1)], match.group(1)))\n\n\ndef GetLineWidth(line):\n  \"\"\"Determines the width of the line in column positions.\n\n  Args:\n    line: A string, which may be a Unicode string.\n\n  Returns:\n    The width of the line in column positions, accounting for Unicode\n    combining characters and wide characters.\n  \"\"\"\n  if isinstance(line, unicode):\n    width = 0\n    for uc in unicodedata.normalize('NFC', line):\n      if unicodedata.east_asian_width(uc) in ('W', 'F'):\n        width += 2\n      elif not unicodedata.combining(uc):\n        width += 1\n    return width\n  else:\n    return len(line)\n\n\ndef CheckStyle(filename, clean_lines, linenum, file_extension, nesting_state,\n               error):\n  \"\"\"Checks rules from the 'C++ style rules' section of cppguide.html.\n\n  Most of these rules are hard to test (naming, comment style), but we\n  do what we can.  In particular we check for 2-space indents, line lengths,\n  tab usage, spaces inside code, etc.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    file_extension: The extension (without the dot) of the filename.\n    nesting_state: A NestingState instance which maintains information about\n                   the current stack of nested blocks being parsed.\n    error: The function to call with any errors found.\n  \"\"\"\n\n  # Don't use \"elided\" lines here, otherwise we can't check commented lines.\n  # Don't want to use \"raw\" either, because we don't want to check inside C++11\n  # raw strings,\n  raw_lines = clean_lines.lines_without_raw_strings\n  line = raw_lines[linenum]\n  prev = raw_lines[linenum - 1] if linenum > 0 else ''\n\n  if line.find('\\t') != -1:\n    error(filename, linenum, 'whitespace/tab', 1,\n          'Tab found; better to use spaces')\n\n  # One or three blank spaces at the beginning of the line is weird; it's\n  # hard to reconcile that with 2-space indents.\n  # NOTE: here are the conditions rob pike used for his tests.  Mine aren't\n  # as sophisticated, but it may be worth becoming so:  RLENGTH==initial_spaces\n  # if(RLENGTH > 20) complain = 0;\n  # if(match($0, \" +(error|private|public|protected):\")) complain = 0;\n  # if(match(prev, \"&& *$\")) complain = 0;\n  # if(match(prev, \"\\\\|\\\\| *$\")) complain = 0;\n  # if(match(prev, \"[\\\",=><] *$\")) complain = 0;\n  # if(match($0, \" <<\")) complain = 0;\n  # if(match(prev, \" +for \\\\(\")) complain = 0;\n  # if(prevodd && match(prevprev, \" +for \\\\(\")) complain = 0;\n  scope_or_label_pattern = r'\\s*\\w+\\s*:\\s*\\\\?$'\n  classinfo = nesting_state.InnermostClass()\n  initial_spaces = 0\n  cleansed_line = clean_lines.elided[linenum]\n  while initial_spaces < len(line) and line[initial_spaces] == ' ':\n    initial_spaces += 1\n  # There are certain situations we allow one space, notably for\n  # section labels, and also lines containing multi-line raw strings.\n  # We also don't check for lines that look like continuation lines\n  # (of lines ending in double quotes, commas, equals, or angle brackets)\n  # because the rules for how to indent those are non-trivial.\n  if (not Search(r'[\",=><] *$', prev) and\n      (initial_spaces == 1 or initial_spaces == 3) and\n      not Match(scope_or_label_pattern, cleansed_line) and\n      not (clean_lines.raw_lines[linenum] != line and\n           Match(r'^\\s*\"\"', line))):\n    error(filename, linenum, 'whitespace/indent', 3,\n          'Weird number of spaces at line-start.  '\n          'Are you using a 2-space indent?')\n\n  if line and line[-1].isspace():\n    error(filename, linenum, 'whitespace/end_of_line', 4,\n          'Line ends in whitespace.  Consider deleting these extra spaces.')\n\n  # Check if the line is a header guard.\n  is_header_guard = False\n  if file_extension in GetHeaderExtensions():\n    cppvar = GetHeaderGuardCPPVariable(filename)\n    if (line.startswith('#ifndef %s' % cppvar) or\n        line.startswith('#define %s' % cppvar) or\n        line.startswith('#endif  // %s' % cppvar)):\n      is_header_guard = True\n  # #include lines and header guards can be long, since there's no clean way to\n  # split them.\n  #\n  # URLs can be long too.  It's possible to split these, but it makes them\n  # harder to cut&paste.\n  #\n  # The \"$Id:...$\" comment may also get very long without it being the\n  # developers fault.\n  #\n  # Doxygen documentation copying can get pretty long when using an overloaded\n  # function declaration\n  if (not line.startswith('#include') and not is_header_guard and\n      not Match(r'^\\s*//.*http(s?)://\\S*$', line) and\n      not Match(r'^\\s*//\\s*[^\\s]*$', line) and\n      not Match(r'^// \\$Id:.*#[0-9]+ \\$$', line) and\n      not Match(r'^\\s*/// [@\\\\](copydoc|copydetails|copybrief) .*$', line)):\n    line_width = GetLineWidth(line)\n    if line_width > _line_length:\n      error(filename, linenum, 'whitespace/line_length', 2,\n            'Lines should be <= %i characters long' % _line_length)\n\n  if (cleansed_line.count(';') > 1 and\n      # allow simple single line lambdas\n      not Match(r'^[^{};]*\\[[^\\[\\]]*\\][^{}]*\\{[^{}\\n\\r]*\\}',\n                line) and\n      # for loops are allowed two ;'s (and may run over two lines).\n      cleansed_line.find('for') == -1 and\n      (GetPreviousNonBlankLine(clean_lines, linenum)[0].find('for') == -1 or\n       GetPreviousNonBlankLine(clean_lines, linenum)[0].find(';') != -1) and\n      # It's ok to have many commands in a switch case that fits in 1 line\n      not ((cleansed_line.find('case ') != -1 or\n            cleansed_line.find('default:') != -1) and\n           cleansed_line.find('break;') != -1)):\n    error(filename, linenum, 'whitespace/newline', 0,\n          'More than one command on the same line')\n\n  # Some more style checks\n  CheckBraces(filename, clean_lines, linenum, error)\n  CheckTrailingSemicolon(filename, clean_lines, linenum, error)\n  CheckEmptyBlockBody(filename, clean_lines, linenum, error)\n  CheckAccess(filename, clean_lines, linenum, nesting_state, error)\n  CheckSpacing(filename, clean_lines, linenum, nesting_state, error)\n  CheckOperatorSpacing(filename, clean_lines, linenum, error)\n  CheckParenthesisSpacing(filename, clean_lines, linenum, error)\n  CheckCommaSpacing(filename, clean_lines, linenum, error)\n  CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error)\n  CheckSpacingForFunctionCall(filename, clean_lines, linenum, error)\n  CheckCheck(filename, clean_lines, linenum, error)\n  CheckAltTokens(filename, clean_lines, linenum, error)\n  classinfo = nesting_state.InnermostClass()\n  if classinfo:\n    CheckSectionSpacing(filename, clean_lines, classinfo, linenum, error)\n\n\n_RE_PATTERN_INCLUDE = re.compile(r'^\\s*#\\s*include\\s*([<\"])([^>\"]*)[>\"].*$')\n# Matches the first component of a filename delimited by -s and _s. That is:\n#  _RE_FIRST_COMPONENT.match('foo').group(0) == 'foo'\n#  _RE_FIRST_COMPONENT.match('foo.cc').group(0) == 'foo'\n#  _RE_FIRST_COMPONENT.match('foo-bar_baz.cc').group(0) == 'foo'\n#  _RE_FIRST_COMPONENT.match('foo_bar-baz.cc').group(0) == 'foo'\n_RE_FIRST_COMPONENT = re.compile(r'^[^-_.]+')\n\n\ndef _DropCommonSuffixes(filename):\n  \"\"\"Drops common suffixes like _test.cc or -inl.h from filename.\n\n  For example:\n    >>> _DropCommonSuffixes('foo/foo-inl.h')\n    'foo/foo'\n    >>> _DropCommonSuffixes('foo/bar/foo.cc')\n    'foo/bar/foo'\n    >>> _DropCommonSuffixes('foo/foo_internal.h')\n    'foo/foo'\n    >>> _DropCommonSuffixes('foo/foo_unusualinternal.h')\n    'foo/foo_unusualinternal'\n\n  Args:\n    filename: The input filename.\n\n  Returns:\n    The filename with the common suffix removed.\n  \"\"\"\n  for suffix in itertools.chain(\n      ('%s.%s' % (test_suffix.lstrip('_'), ext)\n       for test_suffix, ext in itertools.product(_test_suffixes, GetNonHeaderExtensions())),\n      ('%s.%s' % (suffix, ext)\n       for suffix, ext in itertools.product(['inl', 'imp', 'internal'], GetHeaderExtensions()))):\n    if (filename.endswith(suffix) and len(filename) > len(suffix) and\n        filename[-len(suffix) - 1] in ('-', '_')):\n      return filename[:-len(suffix) - 1]\n  return os.path.splitext(filename)[0]\n\n\ndef _ClassifyInclude(fileinfo, include, is_system):\n  \"\"\"Figures out what kind of header 'include' is.\n\n  Args:\n    fileinfo: The current file cpplint is running over. A FileInfo instance.\n    include: The path to a #included file.\n    is_system: True if the #include used <> rather than \"\".\n\n  Returns:\n    One of the _XXX_HEADER constants.\n\n  For example:\n    >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'stdio.h', True)\n    _C_SYS_HEADER\n    >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'string', True)\n    _CPP_SYS_HEADER\n    >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/foo.h', False)\n    _LIKELY_MY_HEADER\n    >>> _ClassifyInclude(FileInfo('foo/foo_unknown_extension.cc'),\n    ...                  'bar/foo_other_ext.h', False)\n    _POSSIBLE_MY_HEADER\n    >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/bar.h', False)\n    _OTHER_HEADER\n  \"\"\"\n  # This is a list of all standard c++ header files, except\n  # those already checked for above.\n  is_cpp_h = include in _CPP_HEADERS\n\n  # Headers with C++ extensions shouldn't be considered C system headers\n  if is_system and os.path.splitext(include)[1] in ['.hpp', '.hxx', '.h++']:\n      is_system = False\n\n  if is_system:\n    if is_cpp_h:\n      return _CPP_SYS_HEADER\n    else:\n      return _C_SYS_HEADER\n\n  # If the target file and the include we're checking share a\n  # basename when we drop common extensions, and the include\n  # lives in . , then it's likely to be owned by the target file.\n  target_dir, target_base = (\n      os.path.split(_DropCommonSuffixes(fileinfo.RepositoryName())))\n  include_dir, include_base = os.path.split(_DropCommonSuffixes(include))\n  target_dir_pub = os.path.normpath(target_dir + '/../public')\n  target_dir_pub = target_dir_pub.replace('\\\\', '/')\n  if target_base == include_base and (\n      include_dir == target_dir or\n      include_dir == target_dir_pub):\n    return _LIKELY_MY_HEADER\n\n  # If the target and include share some initial basename\n  # component, it's possible the target is implementing the\n  # include, so it's allowed to be first, but we'll never\n  # complain if it's not there.\n  target_first_component = _RE_FIRST_COMPONENT.match(target_base)\n  include_first_component = _RE_FIRST_COMPONENT.match(include_base)\n  if (target_first_component and include_first_component and\n      target_first_component.group(0) ==\n      include_first_component.group(0)):\n    return _POSSIBLE_MY_HEADER\n\n  return _OTHER_HEADER\n\n\n\ndef CheckIncludeLine(filename, clean_lines, linenum, include_state, error):\n  \"\"\"Check rules that are applicable to #include lines.\n\n  Strings on #include lines are NOT removed from elided line, to make\n  certain tasks easier. However, to prevent false positives, checks\n  applicable to #include lines in CheckLanguage must be put here.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    include_state: An _IncludeState instance in which the headers are inserted.\n    error: The function to call with any errors found.\n  \"\"\"\n  fileinfo = FileInfo(filename)\n  line = clean_lines.lines[linenum]\n\n  # \"include\" should use the new style \"foo/bar.h\" instead of just \"bar.h\"\n  # Only do this check if the included header follows google naming\n  # conventions.  If not, assume that it's a 3rd party API that\n  # requires special include conventions.\n  #\n  # We also make an exception for Lua headers, which follow google\n  # naming convention but not the include convention.\n  match = Match(r'#include\\s*\"([^/]+\\.h)\"', line)\n  if match and not _THIRD_PARTY_HEADERS_PATTERN.match(match.group(1)):\n    error(filename, linenum, 'build/include_subdir', 4,\n          'Include the directory when naming .h files')\n\n  # we shouldn't include a file more than once. actually, there are a\n  # handful of instances where doing so is okay, but in general it's\n  # not.\n  match = _RE_PATTERN_INCLUDE.search(line)\n  if match:\n    include = match.group(2)\n    is_system = (match.group(1) == '<')\n    duplicate_line = include_state.FindHeader(include)\n    if duplicate_line >= 0:\n      error(filename, linenum, 'build/include', 4,\n            '\"%s\" already included at %s:%s' %\n            (include, filename, duplicate_line))\n      return\n\n    for extension in GetNonHeaderExtensions():\n      if (include.endswith('.' + extension) and\n          os.path.dirname(fileinfo.RepositoryName()) != os.path.dirname(include)):\n        error(filename, linenum, 'build/include', 4,\n              'Do not include .' + extension + ' files from other packages')\n        return\n\n    if not _THIRD_PARTY_HEADERS_PATTERN.match(include):\n      include_state.include_list[-1].append((include, linenum))\n\n      # We want to ensure that headers appear in the right order:\n      # 1) for foo.cc, foo.h  (preferred location)\n      # 2) c system files\n      # 3) cpp system files\n      # 4) for foo.cc, foo.h  (deprecated location)\n      # 5) other google headers\n      #\n      # We classify each include statement as one of those 5 types\n      # using a number of techniques. The include_state object keeps\n      # track of the highest type seen, and complains if we see a\n      # lower type after that.\n      error_message = include_state.CheckNextIncludeOrder(\n          _ClassifyInclude(fileinfo, include, is_system))\n      if error_message:\n        error(filename, linenum, 'build/include_order', 4,\n              '%s. Should be: %s.h, c system, c++ system, other.' %\n              (error_message, fileinfo.BaseName()))\n      canonical_include = include_state.CanonicalizeAlphabeticalOrder(include)\n      if not include_state.IsInAlphabeticalOrder(\n          clean_lines, linenum, canonical_include):\n        error(filename, linenum, 'build/include_alpha', 4,\n              'Include \"%s\" not in alphabetical order' % include)\n      include_state.SetLastHeader(canonical_include)\n\n\n\ndef _GetTextInside(text, start_pattern):\n  r\"\"\"Retrieves all the text between matching open and close parentheses.\n\n  Given a string of lines and a regular expression string, retrieve all the text\n  following the expression and between opening punctuation symbols like\n  (, [, or {, and the matching close-punctuation symbol. This properly nested\n  occurrences of the punctuations, so for the text like\n    printf(a(), b(c()));\n  a call to _GetTextInside(text, r'printf\\(') will return 'a(), b(c())'.\n  start_pattern must match string having an open punctuation symbol at the end.\n\n  Args:\n    text: The lines to extract text. Its comments and strings must be elided.\n           It can be single line and can span multiple lines.\n    start_pattern: The regexp string indicating where to start extracting\n                   the text.\n  Returns:\n    The extracted text.\n    None if either the opening string or ending punctuation could not be found.\n  \"\"\"\n  # TODO(unknown): Audit cpplint.py to see what places could be profitably\n  # rewritten to use _GetTextInside (and use inferior regexp matching today).\n\n  # Give opening punctuations to get the matching close-punctuations.\n  matching_punctuation = {'(': ')', '{': '}', '[': ']'}\n  closing_punctuation = set(itervalues(matching_punctuation))\n\n  # Find the position to start extracting text.\n  match = re.search(start_pattern, text, re.M)\n  if not match:  # start_pattern not found in text.\n    return None\n  start_position = match.end(0)\n\n  assert start_position > 0, (\n      'start_pattern must ends with an opening punctuation.')\n  assert text[start_position - 1] in matching_punctuation, (\n      'start_pattern must ends with an opening punctuation.')\n  # Stack of closing punctuations we expect to have in text after position.\n  punctuation_stack = [matching_punctuation[text[start_position - 1]]]\n  position = start_position\n  while punctuation_stack and position < len(text):\n    if text[position] == punctuation_stack[-1]:\n      punctuation_stack.pop()\n    elif text[position] in closing_punctuation:\n      # A closing punctuation without matching opening punctuations.\n      return None\n    elif text[position] in matching_punctuation:\n      punctuation_stack.append(matching_punctuation[text[position]])\n    position += 1\n  if punctuation_stack:\n    # Opening punctuations left without matching close-punctuations.\n    return None\n  # punctuations match.\n  return text[start_position:position - 1]\n\n\n# Patterns for matching call-by-reference parameters.\n#\n# Supports nested templates up to 2 levels deep using this messy pattern:\n#   < (?: < (?: < [^<>]*\n#               >\n#           |   [^<>] )*\n#         >\n#     |   [^<>] )*\n#   >\n_RE_PATTERN_IDENT = r'[_a-zA-Z]\\w*'  # =~ [[:alpha:]][[:alnum:]]*\n_RE_PATTERN_TYPE = (\n    r'(?:const\\s+)?(?:typename\\s+|class\\s+|struct\\s+|union\\s+|enum\\s+)?'\n    r'(?:\\w|'\n    r'\\s*<(?:<(?:<[^<>]*>|[^<>])*>|[^<>])*>|'\n    r'::)+')\n# A call-by-reference parameter ends with '& identifier'.\n_RE_PATTERN_REF_PARAM = re.compile(\n    r'(' + _RE_PATTERN_TYPE + r'(?:\\s*(?:\\bconst\\b|[*]))*\\s*'\n    r'&\\s*' + _RE_PATTERN_IDENT + r')\\s*(?:=[^,()]+)?[,)]')\n# A call-by-const-reference parameter either ends with 'const& identifier'\n# or looks like 'const type& identifier' when 'type' is atomic.\n_RE_PATTERN_CONST_REF_PARAM = (\n    r'(?:.*\\s*\\bconst\\s*&\\s*' + _RE_PATTERN_IDENT +\n    r'|const\\s+' + _RE_PATTERN_TYPE + r'\\s*&\\s*' + _RE_PATTERN_IDENT + r')')\n# Stream types.\n_RE_PATTERN_REF_STREAM_PARAM = (\n    r'(?:.*stream\\s*&\\s*' + _RE_PATTERN_IDENT + r')')\n\n\ndef CheckLanguage(filename, clean_lines, linenum, file_extension,\n                  include_state, nesting_state, error):\n  \"\"\"Checks rules from the 'C++ language rules' section of cppguide.html.\n\n  Some of these rules are hard to test (function overloading, using\n  uint32 inappropriately), but we do the best we can.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    file_extension: The extension (without the dot) of the filename.\n    include_state: An _IncludeState instance in which the headers are inserted.\n    nesting_state: A NestingState instance which maintains information about\n                   the current stack of nested blocks being parsed.\n    error: The function to call with any errors found.\n  \"\"\"\n  # If the line is empty or consists of entirely a comment, no need to\n  # check it.\n  line = clean_lines.elided[linenum]\n  if not line:\n    return\n\n  match = _RE_PATTERN_INCLUDE.search(line)\n  if match:\n    CheckIncludeLine(filename, clean_lines, linenum, include_state, error)\n    return\n\n  # Reset include state across preprocessor directives.  This is meant\n  # to silence warnings for conditional includes.\n  match = Match(r'^\\s*#\\s*(if|ifdef|ifndef|elif|else|endif)\\b', line)\n  if match:\n    include_state.ResetSection(match.group(1))\n\n\n  # Perform other checks now that we are sure that this is not an include line\n  CheckCasts(filename, clean_lines, linenum, error)\n  CheckGlobalStatic(filename, clean_lines, linenum, error)\n  CheckPrintf(filename, clean_lines, linenum, error)\n\n  if file_extension in GetHeaderExtensions():\n    # TODO(unknown): check that 1-arg constructors are explicit.\n    #                How to tell it's a constructor?\n    #                (handled in CheckForNonStandardConstructs for now)\n    # TODO(unknown): check that classes declare or disable copy/assign\n    #                (level 1 error)\n    pass\n\n  # Check if people are using the verboten C basic types.  The only exception\n  # we regularly allow is \"unsigned short port\" for port.\n  if Search(r'\\bshort port\\b', line):\n    if not Search(r'\\bunsigned short port\\b', line):\n      error(filename, linenum, 'runtime/int', 4,\n            'Use \"unsigned short\" for ports, not \"short\"')\n  else:\n    match = Search(r'\\b(short|long(?! +double)|long long)\\b', line)\n    if match:\n      error(filename, linenum, 'runtime/int', 4,\n            'Use int16/int64/etc, rather than the C type %s' % match.group(1))\n\n  # Check if some verboten operator overloading is going on\n  # TODO(unknown): catch out-of-line unary operator&:\n  #   class X {};\n  #   int operator&(const X& x) { return 42; }  // unary operator&\n  # The trick is it's hard to tell apart from binary operator&:\n  #   class Y { int operator&(const Y& x) { return 23; } }; // binary operator&\n  if Search(r'\\boperator\\s*&\\s*\\(\\s*\\)', line):\n    error(filename, linenum, 'runtime/operator', 4,\n          'Unary operator& is dangerous.  Do not use it.')\n\n  # Check for suspicious usage of \"if\" like\n  # } if (a == b) {\n  if Search(r'\\}\\s*if\\s*\\(', line):\n    error(filename, linenum, 'readability/braces', 4,\n          'Did you mean \"else if\"? If not, start a new line for \"if\".')\n\n  # Check for potential format string bugs like printf(foo).\n  # We constrain the pattern not to pick things like DocidForPrintf(foo).\n  # Not perfect but it can catch printf(foo.c_str()) and printf(foo->c_str())\n  # TODO(unknown): Catch the following case. Need to change the calling\n  # convention of the whole function to process multiple line to handle it.\n  #   printf(\n  #       boy_this_is_a_really_long_variable_that_cannot_fit_on_the_prev_line);\n  printf_args = _GetTextInside(line, r'(?i)\\b(string)?printf\\s*\\(')\n  if printf_args:\n    match = Match(r'([\\w.\\->()]+)$', printf_args)\n    if match and match.group(1) != '__VA_ARGS__':\n      function_name = re.search(r'\\b((?:string)?printf)\\s*\\(',\n                                line, re.I).group(1)\n      error(filename, linenum, 'runtime/printf', 4,\n            'Potential format string bug. Do %s(\"%%s\", %s) instead.'\n            % (function_name, match.group(1)))\n\n  # Check for potential memset bugs like memset(buf, sizeof(buf), 0).\n  match = Search(r'memset\\s*\\(([^,]*),\\s*([^,]*),\\s*0\\s*\\)', line)\n  if match and not Match(r\"^''|-?[0-9]+|0x[0-9A-Fa-f]$\", match.group(2)):\n    error(filename, linenum, 'runtime/memset', 4,\n          'Did you mean \"memset(%s, 0, %s)\"?'\n          % (match.group(1), match.group(2)))\n\n  if Search(r'\\busing namespace\\b', line):\n    if Search(r'\\bliterals\\b', line):\n      error(filename, linenum, 'build/namespaces_literals', 5,\n            'Do not use namespace using-directives.  '\n            'Use using-declarations instead.')\n    else:\n      error(filename, linenum, 'build/namespaces', 5,\n            'Do not use namespace using-directives.  '\n            'Use using-declarations instead.')\n\n  # Detect variable-length arrays.\n  match = Match(r'\\s*(.+::)?(\\w+) [a-z]\\w*\\[(.+)];', line)\n  if (match and match.group(2) != 'return' and match.group(2) != 'delete' and\n      match.group(3).find(']') == -1):\n    # Split the size using space and arithmetic operators as delimiters.\n    # If any of the resulting tokens are not compile time constants then\n    # report the error.\n    tokens = re.split(r'\\s|\\+|\\-|\\*|\\/|<<|>>]', match.group(3))\n    is_const = True\n    skip_next = False\n    for tok in tokens:\n      if skip_next:\n        skip_next = False\n        continue\n\n      if Search(r'sizeof\\(.+\\)', tok): continue\n      if Search(r'arraysize\\(\\w+\\)', tok): continue\n\n      tok = tok.lstrip('(')\n      tok = tok.rstrip(')')\n      if not tok: continue\n      if Match(r'\\d+', tok): continue\n      if Match(r'0[xX][0-9a-fA-F]+', tok): continue\n      if Match(r'k[A-Z0-9]\\w*', tok): continue\n      if Match(r'(.+::)?k[A-Z0-9]\\w*', tok): continue\n      if Match(r'(.+::)?[A-Z][A-Z0-9_]*', tok): continue\n      # A catch all for tricky sizeof cases, including 'sizeof expression',\n      # 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)'\n      # requires skipping the next token because we split on ' ' and '*'.\n      if tok.startswith('sizeof'):\n        skip_next = True\n        continue\n      is_const = False\n      break\n    if not is_const:\n      error(filename, linenum, 'runtime/arrays', 1,\n            'Do not use variable-length arrays.  Use an appropriately named '\n            \"('k' followed by CamelCase) compile-time constant for the size.\")\n\n  # Check for use of unnamed namespaces in header files.  Registration\n  # macros are typically OK, so we allow use of \"namespace {\" on lines\n  # that end with backslashes.\n  if (file_extension in GetHeaderExtensions()\n      and Search(r'\\bnamespace\\s*{', line)\n      and line[-1] != '\\\\'):\n    error(filename, linenum, 'build/namespaces', 4,\n          'Do not use unnamed namespaces in header files.  See '\n          'https://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces'\n          ' for more information.')\n\n\ndef CheckGlobalStatic(filename, clean_lines, linenum, error):\n  \"\"\"Check for unsafe global or static objects.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n\n  # Match two lines at a time to support multiline declarations\n  if linenum + 1 < clean_lines.NumLines() and not Search(r'[;({]', line):\n    line += clean_lines.elided[linenum + 1].strip()\n\n  # Check for people declaring static/global STL strings at the top level.\n  # This is dangerous because the C++ language does not guarantee that\n  # globals with constructors are initialized before the first access, and\n  # also because globals can be destroyed when some threads are still running.\n  # TODO(unknown): Generalize this to also find static unique_ptr instances.\n  # TODO(unknown): File bugs for clang-tidy to find these.\n  match = Match(\n      r'((?:|static +)(?:|const +))(?::*std::)?string( +const)? +'\n      r'([a-zA-Z0-9_:]+)\\b(.*)',\n      line)\n\n  # Remove false positives:\n  # - String pointers (as opposed to values).\n  #    string *pointer\n  #    const string *pointer\n  #    string const *pointer\n  #    string *const pointer\n  #\n  # - Functions and template specializations.\n  #    string Function<Type>(...\n  #    string Class<Type>::Method(...\n  #\n  # - Operators.  These are matched separately because operator names\n  #   cross non-word boundaries, and trying to match both operators\n  #   and functions at the same time would decrease accuracy of\n  #   matching identifiers.\n  #    string Class::operator*()\n  if (match and\n      not Search(r'\\bstring\\b(\\s+const)?\\s*[\\*\\&]\\s*(const\\s+)?\\w', line) and\n      not Search(r'\\boperator\\W', line) and\n      not Match(r'\\s*(<.*>)?(::[a-zA-Z0-9_]+)*\\s*\\(([^\"]|$)', match.group(4))):\n    if Search(r'\\bconst\\b', line):\n      error(filename, linenum, 'runtime/string', 4,\n            'For a static/global string constant, use a C style string '\n            'instead: \"%schar%s %s[]\".' %\n            (match.group(1), match.group(2) or '', match.group(3)))\n    else:\n      error(filename, linenum, 'runtime/string', 4,\n            'Static/global string variables are not permitted.')\n\n  if (Search(r'\\b([A-Za-z0-9_]*_)\\(\\1\\)', line) or\n      Search(r'\\b([A-Za-z0-9_]*_)\\(CHECK_NOTNULL\\(\\1\\)\\)', line)):\n    error(filename, linenum, 'runtime/init', 4,\n          'You seem to be initializing a member variable with itself.')\n\n\ndef CheckPrintf(filename, clean_lines, linenum, error):\n  \"\"\"Check for printf related issues.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n\n  # When snprintf is used, the second argument shouldn't be a literal.\n  match = Search(r'snprintf\\s*\\(([^,]*),\\s*([0-9]*)\\s*,', line)\n  if match and match.group(2) != '0':\n    # If 2nd arg is zero, snprintf is used to calculate size.\n    error(filename, linenum, 'runtime/printf', 3,\n          'If you can, use sizeof(%s) instead of %s as the 2nd arg '\n          'to snprintf.' % (match.group(1), match.group(2)))\n\n  # Check if some verboten C functions are being used.\n  if Search(r'\\bsprintf\\s*\\(', line):\n    error(filename, linenum, 'runtime/printf', 5,\n          'Never use sprintf. Use snprintf instead.')\n  match = Search(r'\\b(strcpy|strcat)\\s*\\(', line)\n  if match:\n    error(filename, linenum, 'runtime/printf', 4,\n          'Almost always, snprintf is better than %s' % match.group(1))\n\n\ndef IsDerivedFunction(clean_lines, linenum):\n  \"\"\"Check if current line contains an inherited function.\n\n  Args:\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n  Returns:\n    True if current line contains a function with \"override\"\n    virt-specifier.\n  \"\"\"\n  # Scan back a few lines for start of current function\n  for i in xrange(linenum, max(-1, linenum - 10), -1):\n    match = Match(r'^([^()]*\\w+)\\(', clean_lines.elided[i])\n    if match:\n      # Look for \"override\" after the matching closing parenthesis\n      line, _, closing_paren = CloseExpression(\n          clean_lines, i, len(match.group(1)))\n      return (closing_paren >= 0 and\n              Search(r'\\boverride\\b', line[closing_paren:]))\n  return False\n\n\ndef IsOutOfLineMethodDefinition(clean_lines, linenum):\n  \"\"\"Check if current line contains an out-of-line method definition.\n\n  Args:\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n  Returns:\n    True if current line contains an out-of-line method definition.\n  \"\"\"\n  # Scan back a few lines for start of current function\n  for i in xrange(linenum, max(-1, linenum - 10), -1):\n    if Match(r'^([^()]*\\w+)\\(', clean_lines.elided[i]):\n      return Match(r'^[^()]*\\w+::\\w+\\(', clean_lines.elided[i]) is not None\n  return False\n\n\ndef IsInitializerList(clean_lines, linenum):\n  \"\"\"Check if current line is inside constructor initializer list.\n\n  Args:\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n  Returns:\n    True if current line appears to be inside constructor initializer\n    list, False otherwise.\n  \"\"\"\n  for i in xrange(linenum, 1, -1):\n    line = clean_lines.elided[i]\n    if i == linenum:\n      remove_function_body = Match(r'^(.*)\\{\\s*$', line)\n      if remove_function_body:\n        line = remove_function_body.group(1)\n\n    if Search(r'\\s:\\s*\\w+[({]', line):\n      # A lone colon tend to indicate the start of a constructor\n      # initializer list.  It could also be a ternary operator, which\n      # also tend to appear in constructor initializer lists as\n      # opposed to parameter lists.\n      return True\n    if Search(r'\\}\\s*,\\s*$', line):\n      # A closing brace followed by a comma is probably the end of a\n      # brace-initialized member in constructor initializer list.\n      return True\n    if Search(r'[{};]\\s*$', line):\n      # Found one of the following:\n      # - A closing brace or semicolon, probably the end of the previous\n      #   function.\n      # - An opening brace, probably the start of current class or namespace.\n      #\n      # Current line is probably not inside an initializer list since\n      # we saw one of those things without seeing the starting colon.\n      return False\n\n  # Got to the beginning of the file without seeing the start of\n  # constructor initializer list.\n  return False\n\n\ndef CheckForNonConstReference(filename, clean_lines, linenum,\n                              nesting_state, error):\n  \"\"\"Check for non-const references.\n\n  Separate from CheckLanguage since it scans backwards from current\n  line, instead of scanning forward.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    nesting_state: A NestingState instance which maintains information about\n                   the current stack of nested blocks being parsed.\n    error: The function to call with any errors found.\n  \"\"\"\n  # Do nothing if there is no '&' on current line.\n  line = clean_lines.elided[linenum]\n  if '&' not in line:\n    return\n\n  # If a function is inherited, current function doesn't have much of\n  # a choice, so any non-const references should not be blamed on\n  # derived function.\n  if IsDerivedFunction(clean_lines, linenum):\n    return\n\n  # Don't warn on out-of-line method definitions, as we would warn on the\n  # in-line declaration, if it isn't marked with 'override'.\n  if IsOutOfLineMethodDefinition(clean_lines, linenum):\n    return\n\n  # Long type names may be broken across multiple lines, usually in one\n  # of these forms:\n  #   LongType\n  #       ::LongTypeContinued &identifier\n  #   LongType::\n  #       LongTypeContinued &identifier\n  #   LongType<\n  #       ...>::LongTypeContinued &identifier\n  #\n  # If we detected a type split across two lines, join the previous\n  # line to current line so that we can match const references\n  # accordingly.\n  #\n  # Note that this only scans back one line, since scanning back\n  # arbitrary number of lines would be expensive.  If you have a type\n  # that spans more than 2 lines, please use a typedef.\n  if linenum > 1:\n    previous = None\n    if Match(r'\\s*::(?:[\\w<>]|::)+\\s*&\\s*\\S', line):\n      # previous_line\\n + ::current_line\n      previous = Search(r'\\b((?:const\\s*)?(?:[\\w<>]|::)+[\\w<>])\\s*$',\n                        clean_lines.elided[linenum - 1])\n    elif Match(r'\\s*[a-zA-Z_]([\\w<>]|::)+\\s*&\\s*\\S', line):\n      # previous_line::\\n + current_line\n      previous = Search(r'\\b((?:const\\s*)?(?:[\\w<>]|::)+::)\\s*$',\n                        clean_lines.elided[linenum - 1])\n    if previous:\n      line = previous.group(1) + line.lstrip()\n    else:\n      # Check for templated parameter that is split across multiple lines\n      endpos = line.rfind('>')\n      if endpos > -1:\n        (_, startline, startpos) = ReverseCloseExpression(\n            clean_lines, linenum, endpos)\n        if startpos > -1 and startline < linenum:\n          # Found the matching < on an earlier line, collect all\n          # pieces up to current line.\n          line = ''\n          for i in xrange(startline, linenum + 1):\n            line += clean_lines.elided[i].strip()\n\n  # Check for non-const references in function parameters.  A single '&' may\n  # found in the following places:\n  #   inside expression: binary & for bitwise AND\n  #   inside expression: unary & for taking the address of something\n  #   inside declarators: reference parameter\n  # We will exclude the first two cases by checking that we are not inside a\n  # function body, including one that was just introduced by a trailing '{'.\n  # TODO(unknown): Doesn't account for 'catch(Exception& e)' [rare].\n  if (nesting_state.previous_stack_top and\n      not (isinstance(nesting_state.previous_stack_top, _ClassInfo) or\n           isinstance(nesting_state.previous_stack_top, _NamespaceInfo))):\n    # Not at toplevel, not within a class, and not within a namespace\n    return\n\n  # Avoid initializer lists.  We only need to scan back from the\n  # current line for something that starts with ':'.\n  #\n  # We don't need to check the current line, since the '&' would\n  # appear inside the second set of parentheses on the current line as\n  # opposed to the first set.\n  if linenum > 0:\n    for i in xrange(linenum - 1, max(0, linenum - 10), -1):\n      previous_line = clean_lines.elided[i]\n      if not Search(r'[),]\\s*$', previous_line):\n        break\n      if Match(r'^\\s*:\\s+\\S', previous_line):\n        return\n\n  # Avoid preprocessors\n  if Search(r'\\\\\\s*$', line):\n    return\n\n  # Avoid constructor initializer lists\n  if IsInitializerList(clean_lines, linenum):\n    return\n\n  # We allow non-const references in a few standard places, like functions\n  # called \"swap()\" or iostream operators like \"<<\" or \">>\".  Do not check\n  # those function parameters.\n  #\n  # We also accept & in static_assert, which looks like a function but\n  # it's actually a declaration expression.\n  whitelisted_functions = (r'(?:[sS]wap(?:<\\w:+>)?|'\n                           r'operator\\s*[<>][<>]|'\n                           r'static_assert|COMPILE_ASSERT'\n                           r')\\s*\\(')\n  if Search(whitelisted_functions, line):\n    return\n  elif not Search(r'\\S+\\([^)]*$', line):\n    # Don't see a whitelisted function on this line.  Actually we\n    # didn't see any function name on this line, so this is likely a\n    # multi-line parameter list.  Try a bit harder to catch this case.\n    for i in xrange(2):\n      if (linenum > i and\n          Search(whitelisted_functions, clean_lines.elided[linenum - i - 1])):\n        return\n\n  decls = ReplaceAll(r'{[^}]*}', ' ', line)  # exclude function body\n  for parameter in re.findall(_RE_PATTERN_REF_PARAM, decls):\n    if (not Match(_RE_PATTERN_CONST_REF_PARAM, parameter) and\n        not Match(_RE_PATTERN_REF_STREAM_PARAM, parameter)):\n      error(filename, linenum, 'runtime/references', 2,\n            'Is this a non-const reference? '\n            'If so, make const or use a pointer: ' +\n            ReplaceAll(' *<', '<', parameter))\n\n\ndef CheckCasts(filename, clean_lines, linenum, error):\n  \"\"\"Various cast related checks.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n\n  # Check to see if they're using an conversion function cast.\n  # I just try to capture the most common basic types, though there are more.\n  # Parameterless conversion functions, such as bool(), are allowed as they are\n  # probably a member operator declaration or default constructor.\n  match = Search(\n      r'(\\bnew\\s+(?:const\\s+)?|\\S<\\s*(?:const\\s+)?)?\\b'\n      r'(int|float|double|bool|char|int32|uint32|int64|uint64)'\n      r'(\\([^)].*)', line)\n  expecting_function = ExpectingFunctionArgs(clean_lines, linenum)\n  if match and not expecting_function:\n    matched_type = match.group(2)\n\n    # matched_new_or_template is used to silence two false positives:\n    # - New operators\n    # - Template arguments with function types\n    #\n    # For template arguments, we match on types immediately following\n    # an opening bracket without any spaces.  This is a fast way to\n    # silence the common case where the function type is the first\n    # template argument.  False negative with less-than comparison is\n    # avoided because those operators are usually followed by a space.\n    #\n    #   function<double(double)>   // bracket + no space = false positive\n    #   value < double(42)         // bracket + space = true positive\n    matched_new_or_template = match.group(1)\n\n    # Avoid arrays by looking for brackets that come after the closing\n    # parenthesis.\n    if Match(r'\\([^()]+\\)\\s*\\[', match.group(3)):\n      return\n\n    # Other things to ignore:\n    # - Function pointers\n    # - Casts to pointer types\n    # - Placement new\n    # - Alias declarations\n    matched_funcptr = match.group(3)\n    if (matched_new_or_template is None and\n        not (matched_funcptr and\n             (Match(r'\\((?:[^() ]+::\\s*\\*\\s*)?[^() ]+\\)\\s*\\(',\n                    matched_funcptr) or\n              matched_funcptr.startswith('(*)'))) and\n        not Match(r'\\s*using\\s+\\S+\\s*=\\s*' + matched_type, line) and\n        not Search(r'new\\(\\S+\\)\\s*' + matched_type, line)):\n      error(filename, linenum, 'readability/casting', 4,\n            'Using deprecated casting style.  '\n            'Use static_cast<%s>(...) instead' %\n            matched_type)\n\n  if not expecting_function:\n    CheckCStyleCast(filename, clean_lines, linenum, 'static_cast',\n                    r'\\((int|float|double|bool|char|u?int(16|32|64))\\)', error)\n\n  # This doesn't catch all cases. Consider (const char * const)\"hello\".\n  #\n  # (char *) \"foo\" should always be a const_cast (reinterpret_cast won't\n  # compile).\n  if CheckCStyleCast(filename, clean_lines, linenum, 'const_cast',\n                     r'\\((char\\s?\\*+\\s?)\\)\\s*\"', error):\n    pass\n  else:\n    # Check pointer casts for other than string constants\n    CheckCStyleCast(filename, clean_lines, linenum, 'reinterpret_cast',\n                    r'\\((\\w+\\s?\\*+\\s?)\\)', error)\n\n  # In addition, we look for people taking the address of a cast.  This\n  # is dangerous -- casts can assign to temporaries, so the pointer doesn't\n  # point where you think.\n  #\n  # Some non-identifier character is required before the '&' for the\n  # expression to be recognized as a cast.  These are casts:\n  #   expression = &static_cast<int*>(temporary());\n  #   function(&(int*)(temporary()));\n  #\n  # This is not a cast:\n  #   reference_type&(int* function_param);\n  match = Search(\n      r'(?:[^\\w]&\\(([^)*][^)]*)\\)[\\w(])|'\n      r'(?:[^\\w]&(static|dynamic|down|reinterpret)_cast\\b)', line)\n  if match:\n    # Try a better error message when the & is bound to something\n    # dereferenced by the casted pointer, as opposed to the casted\n    # pointer itself.\n    parenthesis_error = False\n    match = Match(r'^(.*&(?:static|dynamic|down|reinterpret)_cast\\b)<', line)\n    if match:\n      _, y1, x1 = CloseExpression(clean_lines, linenum, len(match.group(1)))\n      if x1 >= 0 and clean_lines.elided[y1][x1] == '(':\n        _, y2, x2 = CloseExpression(clean_lines, y1, x1)\n        if x2 >= 0:\n          extended_line = clean_lines.elided[y2][x2:]\n          if y2 < clean_lines.NumLines() - 1:\n            extended_line += clean_lines.elided[y2 + 1]\n          if Match(r'\\s*(?:->|\\[)', extended_line):\n            parenthesis_error = True\n\n    if parenthesis_error:\n      error(filename, linenum, 'readability/casting', 4,\n            ('Are you taking an address of something dereferenced '\n             'from a cast?  Wrapping the dereferenced expression in '\n             'parentheses will make the binding more obvious'))\n    else:\n      error(filename, linenum, 'runtime/casting', 4,\n            ('Are you taking an address of a cast?  '\n             'This is dangerous: could be a temp var.  '\n             'Take the address before doing the cast, rather than after'))\n\n\ndef CheckCStyleCast(filename, clean_lines, linenum, cast_type, pattern, error):\n  \"\"\"Checks for a C-style cast by looking for the pattern.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    cast_type: The string for the C++ cast to recommend.  This is either\n      reinterpret_cast, static_cast, or const_cast, depending.\n    pattern: The regular expression used to find C-style casts.\n    error: The function to call with any errors found.\n\n  Returns:\n    True if an error was emitted.\n    False otherwise.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n  match = Search(pattern, line)\n  if not match:\n    return False\n\n  # Exclude lines with keywords that tend to look like casts\n  context = line[0:match.start(1) - 1]\n  if Match(r'.*\\b(?:sizeof|alignof|alignas|[_A-Z][_A-Z0-9]*)\\s*$', context):\n    return False\n\n  # Try expanding current context to see if we one level of\n  # parentheses inside a macro.\n  if linenum > 0:\n    for i in xrange(linenum - 1, max(0, linenum - 5), -1):\n      context = clean_lines.elided[i] + context\n  if Match(r'.*\\b[_A-Z][_A-Z0-9]*\\s*\\((?:\\([^()]*\\)|[^()])*$', context):\n    return False\n\n  # operator++(int) and operator--(int)\n  if context.endswith(' operator++') or context.endswith(' operator--'):\n    return False\n\n  # A single unnamed argument for a function tends to look like old style cast.\n  # If we see those, don't issue warnings for deprecated casts.\n  remainder = line[match.end(0):]\n  if Match(r'^\\s*(?:;|const\\b|throw\\b|final\\b|override\\b|[=>{),]|->)',\n           remainder):\n    return False\n\n  # At this point, all that should be left is actual casts.\n  error(filename, linenum, 'readability/casting', 4,\n        'Using C-style cast.  Use %s<%s>(...) instead' %\n        (cast_type, match.group(1)))\n\n  return True\n\n\ndef ExpectingFunctionArgs(clean_lines, linenum):\n  \"\"\"Checks whether where function type arguments are expected.\n\n  Args:\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n\n  Returns:\n    True if the line at 'linenum' is inside something that expects arguments\n    of function types.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n  return (Match(r'^\\s*MOCK_(CONST_)?METHOD\\d+(_T)?\\(', line) or\n          (linenum >= 2 and\n           (Match(r'^\\s*MOCK_(?:CONST_)?METHOD\\d+(?:_T)?\\((?:\\S+,)?\\s*$',\n                  clean_lines.elided[linenum - 1]) or\n            Match(r'^\\s*MOCK_(?:CONST_)?METHOD\\d+(?:_T)?\\(\\s*$',\n                  clean_lines.elided[linenum - 2]) or\n            Search(r'\\bstd::m?function\\s*\\<\\s*$',\n                   clean_lines.elided[linenum - 1]))))\n\n\n_HEADERS_CONTAINING_TEMPLATES = (\n    ('<deque>', ('deque',)),\n    ('<functional>', ('unary_function', 'binary_function',\n                      'plus', 'minus', 'multiplies', 'divides', 'modulus',\n                      'negate',\n                      'equal_to', 'not_equal_to', 'greater', 'less',\n                      'greater_equal', 'less_equal',\n                      'logical_and', 'logical_or', 'logical_not',\n                      'unary_negate', 'not1', 'binary_negate', 'not2',\n                      'bind1st', 'bind2nd',\n                      'pointer_to_unary_function',\n                      'pointer_to_binary_function',\n                      'ptr_fun',\n                      'mem_fun_t', 'mem_fun', 'mem_fun1_t', 'mem_fun1_ref_t',\n                      'mem_fun_ref_t',\n                      'const_mem_fun_t', 'const_mem_fun1_t',\n                      'const_mem_fun_ref_t', 'const_mem_fun1_ref_t',\n                      'mem_fun_ref',\n                     )),\n    ('<limits>', ('numeric_limits',)),\n    ('<list>', ('list',)),\n    ('<map>', ('map', 'multimap',)),\n    ('<memory>', ('allocator', 'make_shared', 'make_unique', 'shared_ptr',\n                  'unique_ptr', 'weak_ptr')),\n    ('<queue>', ('queue', 'priority_queue',)),\n    ('<set>', ('set', 'multiset',)),\n    ('<stack>', ('stack',)),\n    ('<string>', ('char_traits', 'basic_string',)),\n    ('<tuple>', ('tuple',)),\n    ('<unordered_map>', ('unordered_map', 'unordered_multimap')),\n    ('<unordered_set>', ('unordered_set', 'unordered_multiset')),\n    ('<utility>', ('pair',)),\n    ('<vector>', ('vector',)),\n\n    # gcc extensions.\n    # Note: std::hash is their hash, ::hash is our hash\n    ('<hash_map>', ('hash_map', 'hash_multimap',)),\n    ('<hash_set>', ('hash_set', 'hash_multiset',)),\n    ('<slist>', ('slist',)),\n    )\n\n_HEADERS_MAYBE_TEMPLATES = (\n    ('<algorithm>', ('copy', 'max', 'min', 'min_element', 'sort',\n                     'transform',\n                    )),\n    ('<utility>', ('forward', 'make_pair', 'move', 'swap')),\n    )\n\n_RE_PATTERN_STRING = re.compile(r'\\bstring\\b')\n\n_re_pattern_headers_maybe_templates = []\nfor _header, _templates in _HEADERS_MAYBE_TEMPLATES:\n  for _template in _templates:\n    # Match max<type>(..., ...), max(..., ...), but not foo->max, foo.max or\n    # type::max().\n    _re_pattern_headers_maybe_templates.append(\n        (re.compile(r'[^>.]\\b' + _template + r'(<.*?>)?\\([^\\)]'),\n            _template,\n            _header))\n\n# Other scripts may reach in and modify this pattern.\n_re_pattern_templates = []\nfor _header, _templates in _HEADERS_CONTAINING_TEMPLATES:\n  for _template in _templates:\n    _re_pattern_templates.append(\n        (re.compile(r'(\\<|\\b)' + _template + r'\\s*\\<'),\n         _template + '<>',\n         _header))\n\n\ndef FilesBelongToSameModule(filename_cc, filename_h):\n  \"\"\"Check if these two filenames belong to the same module.\n\n  The concept of a 'module' here is a as follows:\n  foo.h, foo-inl.h, foo.cc, foo_test.cc and foo_unittest.cc belong to the\n  same 'module' if they are in the same directory.\n  some/path/public/xyzzy and some/path/internal/xyzzy are also considered\n  to belong to the same module here.\n\n  If the filename_cc contains a longer path than the filename_h, for example,\n  '/absolute/path/to/base/sysinfo.cc', and this file would include\n  'base/sysinfo.h', this function also produces the prefix needed to open the\n  header. This is used by the caller of this function to more robustly open the\n  header file. We don't have access to the real include paths in this context,\n  so we need this guesswork here.\n\n  Known bugs: tools/base/bar.cc and base/bar.h belong to the same module\n  according to this implementation. Because of this, this function gives\n  some false positives. This should be sufficiently rare in practice.\n\n  Args:\n    filename_cc: is the path for the source (e.g. .cc) file\n    filename_h: is the path for the header path\n\n  Returns:\n    Tuple with a bool and a string:\n    bool: True if filename_cc and filename_h belong to the same module.\n    string: the additional prefix needed to open the header file.\n  \"\"\"\n  fileinfo_cc = FileInfo(filename_cc)\n  if not fileinfo_cc.Extension().lstrip('.') in GetNonHeaderExtensions():\n    return (False, '')\n\n  fileinfo_h = FileInfo(filename_h)\n  if not fileinfo_h.Extension().lstrip('.') in GetHeaderExtensions():\n    return (False, '')\n\n  filename_cc = filename_cc[:-(len(fileinfo_cc.Extension()))]\n  matched_test_suffix = Search(_TEST_FILE_SUFFIX, fileinfo_cc.BaseName())\n  if matched_test_suffix:\n    filename_cc = filename_cc[:-len(matched_test_suffix.group(1))]\n\n  filename_cc = filename_cc.replace('/public/', '/')\n  filename_cc = filename_cc.replace('/internal/', '/')\n\n  filename_h = filename_h[:-(len(fileinfo_h.Extension()))]\n  if filename_h.endswith('-inl'):\n    filename_h = filename_h[:-len('-inl')]\n  filename_h = filename_h.replace('/public/', '/')\n  filename_h = filename_h.replace('/internal/', '/')\n\n  files_belong_to_same_module = filename_cc.endswith(filename_h)\n  common_path = ''\n  if files_belong_to_same_module:\n    common_path = filename_cc[:-len(filename_h)]\n  return files_belong_to_same_module, common_path\n\n\ndef UpdateIncludeState(filename, include_dict, io=codecs):\n  \"\"\"Fill up the include_dict with new includes found from the file.\n\n  Args:\n    filename: the name of the header to read.\n    include_dict: a dictionary in which the headers are inserted.\n    io: The io factory to use to read the file. Provided for testability.\n\n  Returns:\n    True if a header was successfully added. False otherwise.\n  \"\"\"\n  headerfile = None\n  try:\n    headerfile = io.open(filename, 'r', 'utf8', 'replace')\n  except IOError:\n    return False\n  linenum = 0\n  for line in headerfile:\n    linenum += 1\n    clean_line = CleanseComments(line)\n    match = _RE_PATTERN_INCLUDE.search(clean_line)\n    if match:\n      include = match.group(2)\n      include_dict.setdefault(include, linenum)\n  return True\n\n\ndef CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error,\n                              io=codecs):\n  \"\"\"Reports for missing stl includes.\n\n  This function will output warnings to make sure you are including the headers\n  necessary for the stl containers and functions that you use. We only give one\n  reason to include a header. For example, if you use both equal_to<> and\n  less<> in a .h file, only one (the latter in the file) of these will be\n  reported as a reason to include the <functional>.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    include_state: An _IncludeState instance.\n    error: The function to call with any errors found.\n    io: The IO factory to use to read the header file. Provided for unittest\n        injection.\n  \"\"\"\n  required = {}  # A map of header name to linenumber and the template entity.\n                 # Example of required: { '<functional>': (1219, 'less<>') }\n\n  for linenum in range(clean_lines.NumLines()):\n    line = clean_lines.elided[linenum]\n    if not line or line[0] == '#':\n      continue\n\n    # String is special -- it is a non-templatized type in STL.\n    matched = _RE_PATTERN_STRING.search(line)\n    if matched:\n      # Don't warn about strings in non-STL namespaces:\n      # (We check only the first match per line; good enough.)\n      prefix = line[:matched.start()]\n      if prefix.endswith('std::') or not prefix.endswith('::'):\n        required['<string>'] = (linenum, 'string')\n\n    for pattern, template, header in _re_pattern_headers_maybe_templates:\n      if pattern.search(line):\n        required[header] = (linenum, template)\n\n    # The following function is just a speed up, no semantics are changed.\n    if not '<' in line:  # Reduces the cpu time usage by skipping lines.\n      continue\n\n    for pattern, template, header in _re_pattern_templates:\n      matched = pattern.search(line)\n      if matched:\n        # Don't warn about IWYU in non-STL namespaces:\n        # (We check only the first match per line; good enough.)\n        prefix = line[:matched.start()]\n        if prefix.endswith('std::') or not prefix.endswith('::'):\n          required[header] = (linenum, template)\n\n  # The policy is that if you #include something in foo.h you don't need to\n  # include it again in foo.cc. Here, we will look at possible includes.\n  # Let's flatten the include_state include_list and copy it into a dictionary.\n  include_dict = dict([item for sublist in include_state.include_list\n                       for item in sublist])\n\n  # Did we find the header for this file (if any) and successfully load it?\n  header_found = False\n\n  # Use the absolute path so that matching works properly.\n  abs_filename = FileInfo(filename).FullName()\n\n  # For Emacs's flymake.\n  # If cpplint is invoked from Emacs's flymake, a temporary file is generated\n  # by flymake and that file name might end with '_flymake.cc'. In that case,\n  # restore original file name here so that the corresponding header file can be\n  # found.\n  # e.g. If the file name is 'foo_flymake.cc', we should search for 'foo.h'\n  # instead of 'foo_flymake.h'\n  abs_filename = re.sub(r'_flymake\\.cc$', '.cc', abs_filename)\n\n  # include_dict is modified during iteration, so we iterate over a copy of\n  # the keys.\n  header_keys = list(include_dict.keys())\n  for header in header_keys:\n    (same_module, common_path) = FilesBelongToSameModule(abs_filename, header)\n    fullpath = common_path + header\n    if same_module and UpdateIncludeState(fullpath, include_dict, io):\n      header_found = True\n\n  # If we can't find the header file for a .cc, assume it's because we don't\n  # know where to look. In that case we'll give up as we're not sure they\n  # didn't include it in the .h file.\n  # TODO(unknown): Do a better job of finding .h files so we are confident that\n  # not having the .h file means there isn't one.\n  if not header_found:\n    for extension in GetNonHeaderExtensions():\n      if filename.endswith('.' + extension):\n        return\n\n  # All the lines have been processed, report the errors found.\n  for required_header_unstripped in sorted(required, key=required.__getitem__):\n    template = required[required_header_unstripped][1]\n    if required_header_unstripped.strip('<>\"') not in include_dict:\n      error(filename, required[required_header_unstripped][0],\n            'build/include_what_you_use', 4,\n            'Add #include ' + required_header_unstripped + ' for ' + template)\n\n\n_RE_PATTERN_EXPLICIT_MAKEPAIR = re.compile(r'\\bmake_pair\\s*<')\n\n\ndef CheckMakePairUsesDeduction(filename, clean_lines, linenum, error):\n  \"\"\"Check that make_pair's template arguments are deduced.\n\n  G++ 4.6 in C++11 mode fails badly if make_pair's template arguments are\n  specified explicitly, and such use isn't intended in any case.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n  match = _RE_PATTERN_EXPLICIT_MAKEPAIR.search(line)\n  if match:\n    error(filename, linenum, 'build/explicit_make_pair',\n          4,  # 4 = high confidence\n          'For C++11-compatibility, omit template arguments from make_pair'\n          ' OR use pair directly OR if appropriate, construct a pair directly')\n\n\ndef CheckRedundantVirtual(filename, clean_lines, linenum, error):\n  \"\"\"Check if line contains a redundant \"virtual\" function-specifier.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  # Look for \"virtual\" on current line.\n  line = clean_lines.elided[linenum]\n  virtual = Match(r'^(.*)(\\bvirtual\\b)(.*)$', line)\n  if not virtual: return\n\n  # Ignore \"virtual\" keywords that are near access-specifiers.  These\n  # are only used in class base-specifier and do not apply to member\n  # functions.\n  if (Search(r'\\b(public|protected|private)\\s+$', virtual.group(1)) or\n      Match(r'^\\s+(public|protected|private)\\b', virtual.group(3))):\n    return\n\n  # Ignore the \"virtual\" keyword from virtual base classes.  Usually\n  # there is a column on the same line in these cases (virtual base\n  # classes are rare in google3 because multiple inheritance is rare).\n  if Match(r'^.*[^:]:[^:].*$', line): return\n\n  # Look for the next opening parenthesis.  This is the start of the\n  # parameter list (possibly on the next line shortly after virtual).\n  # TODO(unknown): doesn't work if there are virtual functions with\n  # decltype() or other things that use parentheses, but csearch suggests\n  # that this is rare.\n  end_col = -1\n  end_line = -1\n  start_col = len(virtual.group(2))\n  for start_line in xrange(linenum, min(linenum + 3, clean_lines.NumLines())):\n    line = clean_lines.elided[start_line][start_col:]\n    parameter_list = Match(r'^([^(]*)\\(', line)\n    if parameter_list:\n      # Match parentheses to find the end of the parameter list\n      (_, end_line, end_col) = CloseExpression(\n          clean_lines, start_line, start_col + len(parameter_list.group(1)))\n      break\n    start_col = 0\n\n  if end_col < 0:\n    return  # Couldn't find end of parameter list, give up\n\n  # Look for \"override\" or \"final\" after the parameter list\n  # (possibly on the next few lines).\n  for i in xrange(end_line, min(end_line + 3, clean_lines.NumLines())):\n    line = clean_lines.elided[i][end_col:]\n    match = Search(r'\\b(override|final)\\b', line)\n    if match:\n      error(filename, linenum, 'readability/inheritance', 4,\n            ('\"virtual\" is redundant since function is '\n             'already declared as \"%s\"' % match.group(1)))\n\n    # Set end_col to check whole lines after we are done with the\n    # first line.\n    end_col = 0\n    if Search(r'[^\\w]\\s*$', line):\n      break\n\n\ndef CheckRedundantOverrideOrFinal(filename, clean_lines, linenum, error):\n  \"\"\"Check if line contains a redundant \"override\" or \"final\" virt-specifier.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  # Look for closing parenthesis nearby.  We need one to confirm where\n  # the declarator ends and where the virt-specifier starts to avoid\n  # false positives.\n  line = clean_lines.elided[linenum]\n  declarator_end = line.rfind(')')\n  if declarator_end >= 0:\n    fragment = line[declarator_end:]\n  else:\n    if linenum > 1 and clean_lines.elided[linenum - 1].rfind(')') >= 0:\n      fragment = line\n    else:\n      return\n\n  # Check that at most one of \"override\" or \"final\" is present, not both\n  if Search(r'\\boverride\\b', fragment) and Search(r'\\bfinal\\b', fragment):\n    error(filename, linenum, 'readability/inheritance', 4,\n          ('\"override\" is redundant since function is '\n           'already declared as \"final\"'))\n\n\n\n\n# Returns true if we are at a new block, and it is directly\n# inside of a namespace.\ndef IsBlockInNameSpace(nesting_state, is_forward_declaration):\n  \"\"\"Checks that the new block is directly in a namespace.\n\n  Args:\n    nesting_state: The _NestingState object that contains info about our state.\n    is_forward_declaration: If the class is a forward declared class.\n  Returns:\n    Whether or not the new block is directly in a namespace.\n  \"\"\"\n  if is_forward_declaration:\n    return len(nesting_state.stack) >= 1 and (\n      isinstance(nesting_state.stack[-1], _NamespaceInfo))\n\n\n  return (len(nesting_state.stack) > 1 and\n          nesting_state.stack[-1].check_namespace_indentation and\n          isinstance(nesting_state.stack[-2], _NamespaceInfo))\n\n\ndef ShouldCheckNamespaceIndentation(nesting_state, is_namespace_indent_item,\n                                    raw_lines_no_comments, linenum):\n  \"\"\"This method determines if we should apply our namespace indentation check.\n\n  Args:\n    nesting_state: The current nesting state.\n    is_namespace_indent_item: If we just put a new class on the stack, True.\n      If the top of the stack is not a class, or we did not recently\n      add the class, False.\n    raw_lines_no_comments: The lines without the comments.\n    linenum: The current line number we are processing.\n\n  Returns:\n    True if we should apply our namespace indentation check. Currently, it\n    only works for classes and namespaces inside of a namespace.\n  \"\"\"\n\n  is_forward_declaration = IsForwardClassDeclaration(raw_lines_no_comments,\n                                                     linenum)\n\n  if not (is_namespace_indent_item or is_forward_declaration):\n    return False\n\n  # If we are in a macro, we do not want to check the namespace indentation.\n  if IsMacroDefinition(raw_lines_no_comments, linenum):\n    return False\n\n  return IsBlockInNameSpace(nesting_state, is_forward_declaration)\n\n\n# Call this method if the line is directly inside of a namespace.\n# If the line above is blank (excluding comments) or the start of\n# an inner namespace, it cannot be indented.\ndef CheckItemIndentationInNamespace(filename, raw_lines_no_comments, linenum,\n                                    error):\n  line = raw_lines_no_comments[linenum]\n  if Match(r'^\\s+', line):\n    error(filename, linenum, 'runtime/indentation_namespace', 4,\n          'Do not indent within a namespace')\n\n\ndef ProcessLine(filename, file_extension, clean_lines, line,\n                include_state, function_state, nesting_state, error,\n                extra_check_functions=None):\n  \"\"\"Processes a single line in the file.\n\n  Args:\n    filename: Filename of the file that is being processed.\n    file_extension: The extension (dot not included) of the file.\n    clean_lines: An array of strings, each representing a line of the file,\n                 with comments stripped.\n    line: Number of line being processed.\n    include_state: An _IncludeState instance in which the headers are inserted.\n    function_state: A _FunctionState instance which counts function lines, etc.\n    nesting_state: A NestingState instance which maintains information about\n                   the current stack of nested blocks being parsed.\n    error: A callable to which errors are reported, which takes 4 arguments:\n           filename, line number, error level, and message\n    extra_check_functions: An array of additional check functions that will be\n                           run on each source line. Each function takes 4\n                           arguments: filename, clean_lines, line, error\n  \"\"\"\n  raw_lines = clean_lines.raw_lines\n  ParseNolintSuppressions(filename, raw_lines[line], line, error)\n  nesting_state.Update(filename, clean_lines, line, error)\n  CheckForNamespaceIndentation(filename, nesting_state, clean_lines, line,\n                               error)\n  if nesting_state.InAsmBlock(): return\n  CheckForFunctionLengths(filename, clean_lines, line, function_state, error)\n  CheckForMultilineCommentsAndStrings(filename, clean_lines, line, error)\n  CheckStyle(filename, clean_lines, line, file_extension, nesting_state, error)\n  CheckLanguage(filename, clean_lines, line, file_extension, include_state,\n                nesting_state, error)\n  CheckForNonConstReference(filename, clean_lines, line, nesting_state, error)\n  CheckForNonStandardConstructs(filename, clean_lines, line,\n                                nesting_state, error)\n  CheckVlogArguments(filename, clean_lines, line, error)\n  CheckPosixThreading(filename, clean_lines, line, error)\n  CheckInvalidIncrement(filename, clean_lines, line, error)\n  CheckMakePairUsesDeduction(filename, clean_lines, line, error)\n  CheckRedundantVirtual(filename, clean_lines, line, error)\n  CheckRedundantOverrideOrFinal(filename, clean_lines, line, error)\n  if extra_check_functions:\n    for check_fn in extra_check_functions:\n      check_fn(filename, clean_lines, line, error)\n\ndef FlagCxx11Features(filename, clean_lines, linenum, error):\n  \"\"\"Flag those c++11 features that we only allow in certain places.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n\n  include = Match(r'\\s*#\\s*include\\s+[<\"]([^<\"]+)[\">]', line)\n\n  # Flag unapproved C++ TR1 headers.\n  if include and include.group(1).startswith('tr1/'):\n    error(filename, linenum, 'build/c++tr1', 5,\n          ('C++ TR1 headers such as <%s> are unapproved.') % include.group(1))\n\n  # Flag unapproved C++11 headers.\n  if include and include.group(1) in ('cfenv',\n                                      'condition_variable',\n                                      'fenv.h',\n                                      'future',\n                                      'mutex',\n                                      'thread',\n                                      'chrono',\n                                      'ratio',\n                                      'regex',\n                                      'system_error',\n                                     ):\n    error(filename, linenum, 'build/c++11', 5,\n          ('<%s> is an unapproved C++11 header.') % include.group(1))\n\n  # The only place where we need to worry about C++11 keywords and library\n  # features in preprocessor directives is in macro definitions.\n  if Match(r'\\s*#', line) and not Match(r'\\s*#\\s*define\\b', line): return\n\n  # These are classes and free functions.  The classes are always\n  # mentioned as std::*, but we only catch the free functions if\n  # they're not found by ADL.  They're alphabetical by header.\n  for top_name in (\n      # type_traits\n      'alignment_of',\n      'aligned_union',\n      ):\n    if Search(r'\\bstd::%s\\b' % top_name, line):\n      error(filename, linenum, 'build/c++11', 5,\n            ('std::%s is an unapproved C++11 class or function.  Send c-style '\n             'an example of where it would make your code more readable, and '\n             'they may let you use it.') % top_name)\n\n\ndef FlagCxx14Features(filename, clean_lines, linenum, error):\n  \"\"\"Flag those C++14 features that we restrict.\n\n  Args:\n    filename: The name of the current file.\n    clean_lines: A CleansedLines instance containing the file.\n    linenum: The number of the line to check.\n    error: The function to call with any errors found.\n  \"\"\"\n  line = clean_lines.elided[linenum]\n\n  include = Match(r'\\s*#\\s*include\\s+[<\"]([^<\"]+)[\">]', line)\n\n  # Flag unapproved C++14 headers.\n  if include and include.group(1) in ('scoped_allocator', 'shared_mutex'):\n    error(filename, linenum, 'build/c++14', 5,\n          ('<%s> is an unapproved C++14 header.') % include.group(1))\n\n\ndef ProcessFileData(filename, file_extension, lines, error,\n                    extra_check_functions=None):\n  \"\"\"Performs lint checks and reports any errors to the given error function.\n\n  Args:\n    filename: Filename of the file that is being processed.\n    file_extension: The extension (dot not included) of the file.\n    lines: An array of strings, each representing a line of the file, with the\n           last element being empty if the file is terminated with a newline.\n    error: A callable to which errors are reported, which takes 4 arguments:\n           filename, line number, error level, and message\n    extra_check_functions: An array of additional check functions that will be\n                           run on each source line. Each function takes 4\n                           arguments: filename, clean_lines, line, error\n  \"\"\"\n  lines = (['// marker so line numbers and indices both start at 1'] + lines +\n           ['// marker so line numbers end in a known way'])\n\n  include_state = _IncludeState()\n  function_state = _FunctionState()\n  nesting_state = NestingState()\n\n  ResetNolintSuppressions()\n\n  CheckForCopyright(filename, lines, error)\n  ProcessGlobalSuppresions(lines)\n  RemoveMultiLineComments(filename, lines, error)\n  clean_lines = CleansedLines(lines)\n\n  if file_extension in GetHeaderExtensions():\n    CheckForHeaderGuard(filename, clean_lines, error)\n\n  for line in range(clean_lines.NumLines()):\n    ProcessLine(filename, file_extension, clean_lines, line,\n                include_state, function_state, nesting_state, error,\n                extra_check_functions)\n    FlagCxx11Features(filename, clean_lines, line, error)\n  nesting_state.CheckCompletedBlocks(filename, error)\n\n  CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error)\n\n  # Check that the .cc file has included its header if it exists.\n  if _IsSourceExtension(file_extension):\n    CheckHeaderFileIncluded(filename, include_state, error)\n\n  # We check here rather than inside ProcessLine so that we see raw\n  # lines rather than \"cleaned\" lines.\n  CheckForBadCharacters(filename, lines, error)\n\n  CheckForNewlineAtEOF(filename, lines, error)\n\ndef ProcessConfigOverrides(filename):\n  \"\"\" Loads the configuration files and processes the config overrides.\n\n  Args:\n    filename: The name of the file being processed by the linter.\n\n  Returns:\n    False if the current |filename| should not be processed further.\n  \"\"\"\n\n  abs_filename = os.path.abspath(filename)\n  cfg_filters = []\n  keep_looking = True\n  while keep_looking:\n    abs_path, base_name = os.path.split(abs_filename)\n    if not base_name:\n      break  # Reached the root directory.\n\n    cfg_file = os.path.join(abs_path, \"CPPLINT.cfg\")\n    abs_filename = abs_path\n    if not os.path.isfile(cfg_file):\n      continue\n\n    try:\n      with open(cfg_file) as file_handle:\n        for line in file_handle:\n          line, _, _ = line.partition('#')  # Remove comments.\n          if not line.strip():\n            continue\n\n          name, _, val = line.partition('=')\n          name = name.strip()\n          val = val.strip()\n          if name == 'set noparent':\n            keep_looking = False\n          elif name == 'filter':\n            cfg_filters.append(val)\n          elif name == 'exclude_files':\n            # When matching exclude_files pattern, use the base_name of\n            # the current file name or the directory name we are processing.\n            # For example, if we are checking for lint errors in /foo/bar/baz.cc\n            # and we found the .cfg file at /foo/CPPLINT.cfg, then the config\n            # file's \"exclude_files\" filter is meant to be checked against \"bar\"\n            # and not \"baz\" nor \"bar/baz.cc\".\n            if base_name:\n              pattern = re.compile(val)\n              if pattern.match(base_name):\n                _cpplint_state.PrintInfo('Ignoring \"%s\": file excluded by '\n                    '\"%s\". File path component \"%s\" matches pattern \"%s\"\\n' %\n                    (filename, cfg_file, base_name, val))\n                return False\n          elif name == 'linelength':\n            global _line_length\n            try:\n                _line_length = int(val)\n            except ValueError:\n                _cpplint_state.PrintError('Line length must be numeric.')\n          elif name == 'extensions':\n              global _valid_extensions\n              try:\n                  extensions = [ext.strip() for ext in val.split(',')]\n                  _valid_extensions = set(extensions)\n              except ValueError:\n                  sys.stderr.write('Extensions should be a comma-separated list of values;'\n                                   'for example: extensions=hpp,cpp\\n'\n                                   'This could not be parsed: \"%s\"' % (val,))\n          elif name == 'headers':\n              global _header_extensions\n              try:\n                  extensions = [ext.strip() for ext in val.split(',')]\n                  _header_extensions = set(extensions)\n              except ValueError:\n                  sys.stderr.write('Extensions should be a comma-separated list of values;'\n                                   'for example: extensions=hpp,cpp\\n'\n                                   'This could not be parsed: \"%s\"' % (val,))\n          elif name == 'root':\n            global _root\n            _root = val\n          else:\n            _cpplint_state.PrintError(\n                'Invalid configuration option (%s) in file %s\\n' %\n                (name, cfg_file))\n\n    except IOError:\n      _cpplint_state.PrintError(\n          \"Skipping config file '%s': Can't open for reading\\n\" % cfg_file)\n      keep_looking = False\n\n  # Apply all the accumulated filters in reverse order (top-level directory\n  # config options having the least priority).\n  for cfg_filter in reversed(cfg_filters):\n     _AddFilters(cfg_filter)\n\n  return True\n\n\ndef ProcessFile(filename, vlevel, extra_check_functions=None):\n  \"\"\"Does google-lint on a single file.\n\n  Args:\n    filename: The name of the file to parse.\n\n    vlevel: The level of errors to report.  Every error of confidence\n    >= verbose_level will be reported.  0 is a good default.\n\n    extra_check_functions: An array of additional check functions that will be\n                           run on each source line. Each function takes 4\n                           arguments: filename, clean_lines, line, error\n  \"\"\"\n\n  _SetVerboseLevel(vlevel)\n  _BackupFilters()\n\n  if not ProcessConfigOverrides(filename):\n    _RestoreFilters()\n    return\n\n  lf_lines = []\n  crlf_lines = []\n  try:\n    # Support the UNIX convention of using \"-\" for stdin.  Note that\n    # we are not opening the file with universal newline support\n    # (which codecs doesn't support anyway), so the resulting lines do\n    # contain trailing '\\r' characters if we are reading a file that\n    # has CRLF endings.\n    # If after the split a trailing '\\r' is present, it is removed\n    # below.\n    if filename == '-':\n      lines = codecs.StreamReaderWriter(sys.stdin,\n                                        codecs.getreader('utf8'),\n                                        codecs.getwriter('utf8'),\n                                        'replace').read().split('\\n')\n    else:\n      lines = codecs.open(filename, 'r', 'utf8', 'replace').read().split('\\n')\n\n    # Remove trailing '\\r'.\n    # The -1 accounts for the extra trailing blank line we get from split()\n    for linenum in range(len(lines) - 1):\n      if lines[linenum].endswith('\\r'):\n        lines[linenum] = lines[linenum].rstrip('\\r')\n        crlf_lines.append(linenum + 1)\n      else:\n        lf_lines.append(linenum + 1)\n\n  except IOError:\n    _cpplint_state.PrintError(\n        \"Skipping input '%s': Can't open for reading\\n\" % filename)\n    _RestoreFilters()\n    return\n\n  # Note, if no dot is found, this will give the entire filename as the ext.\n  file_extension = filename[filename.rfind('.') + 1:]\n\n  # When reading from stdin, the extension is unknown, so no cpplint tests\n  # should rely on the extension.\n  if filename != '-' and file_extension not in GetAllExtensions():\n    _cpplint_state.PrintError('Ignoring %s; not a valid file name '\n                     '(%s)\\n' % (filename, ', '.join(GetAllExtensions())))\n  else:\n    ProcessFileData(filename, file_extension, lines, Error,\n                    extra_check_functions)\n\n    # If end-of-line sequences are a mix of LF and CR-LF, issue\n    # warnings on the lines with CR.\n    #\n    # Don't issue any warnings if all lines are uniformly LF or CR-LF,\n    # since critique can handle these just fine, and the style guide\n    # doesn't dictate a particular end of line sequence.\n    #\n    # We can't depend on os.linesep to determine what the desired\n    # end-of-line sequence should be, since that will return the\n    # server-side end-of-line sequence.\n    if lf_lines and crlf_lines:\n      # Warn on every line with CR.  An alternative approach might be to\n      # check whether the file is mostly CRLF or just LF, and warn on the\n      # minority, we bias toward LF here since most tools prefer LF.\n      for linenum in crlf_lines:\n        Error(filename, linenum, 'whitespace/newline', 1,\n              'Unexpected \\\\r (^M) found; better to use only \\\\n')\n\n  _cpplint_state.PrintInfo('Done processing %s\\n' % filename)\n  _RestoreFilters()\n\n\ndef PrintUsage(message):\n  \"\"\"Prints a brief usage string and exits, optionally with an error message.\n\n  Args:\n    message: The optional error message.\n  \"\"\"\n  sys.stderr.write(_USAGE)\n\n  if message:\n    sys.exit('\\nFATAL ERROR: ' + message)\n  else:\n    sys.exit(0)\n\n\ndef PrintCategories():\n  \"\"\"Prints a list of all the error-categories used by error messages.\n\n  These are the categories used to filter messages via --filter.\n  \"\"\"\n  sys.stderr.write(''.join('  %s\\n' % cat for cat in _ERROR_CATEGORIES))\n  sys.exit(0)\n\n\ndef ParseArguments(args):\n  \"\"\"Parses the command line arguments.\n\n  This may set the output format and verbosity level as side-effects.\n\n  Args:\n    args: The command line arguments:\n\n  Returns:\n    The list of filenames to lint.\n  \"\"\"\n  try:\n    (opts, filenames) = getopt.getopt(args, '', ['help', 'output=', 'verbose=',\n                                                 'counting=',\n                                                 'filter=',\n                                                 'root=',\n                                                 'repository=',\n                                                 'linelength=',\n                                                 'extensions=',\n                                                 'exclude=',\n                                                 'headers=',\n                                                 'quiet',\n                                                 'recursive'])\n  except getopt.GetoptError:\n    PrintUsage('Invalid arguments.')\n\n  verbosity = _VerboseLevel()\n  output_format = _OutputFormat()\n  filters = ''\n  counting_style = ''\n  recursive = False\n\n  for (opt, val) in opts:\n    if opt == '--help':\n      PrintUsage(None)\n    elif opt == '--output':\n      if val not in ('emacs', 'vs7', 'eclipse', 'junit'):\n        PrintUsage('The only allowed output formats are emacs, vs7, eclipse '\n                   'and junit.')\n      output_format = val\n    elif opt == '--verbose':\n      verbosity = int(val)\n    elif opt == '--filter':\n      filters = val\n      if not filters:\n        PrintCategories()\n    elif opt == '--counting':\n      if val not in ('total', 'toplevel', 'detailed'):\n        PrintUsage('Valid counting options are total, toplevel, and detailed')\n      counting_style = val\n    elif opt == '--root':\n      global _root\n      _root = val\n    elif opt == '--repository':\n      global _repository\n      _repository = val\n    elif opt == '--linelength':\n      global _line_length\n      try:\n        _line_length = int(val)\n      except ValueError:\n        PrintUsage('Line length must be digits.')\n    elif opt == '--exclude':\n      global _excludes\n      if not _excludes:\n        _excludes = set()\n      _excludes.update(glob.glob(val))\n    elif opt == '--extensions':\n      global _valid_extensions\n      try:\n        _valid_extensions = set(val.split(','))\n      except ValueError:\n          PrintUsage('Extensions must be comma seperated list.')\n    elif opt == '--headers':\n      global _header_extensions\n      try:\n          _header_extensions = set(val.split(','))\n      except ValueError:\n        PrintUsage('Extensions must be comma seperated list.')\n    elif opt == '--recursive':\n      recursive = True\n    elif opt == '--quiet':\n      global _quiet\n      _quiet = True\n\n  if not filenames:\n    PrintUsage('No files were specified.')\n\n  if recursive:\n    filenames = _ExpandDirectories(filenames)\n\n  if _excludes:\n    filenames = _FilterExcludedFiles(filenames)\n\n  _SetOutputFormat(output_format)\n  _SetVerboseLevel(verbosity)\n  _SetFilters(filters)\n  _SetCountingStyle(counting_style)\n\n  return filenames\n\ndef _ExpandDirectories(filenames):\n  \"\"\"Searches a list of filenames and replaces directories in the list with\n  all files descending from those directories. Files with extensions not in\n  the valid extensions list are excluded.\n\n  Args:\n    filenames: A list of files or directories\n\n  Returns:\n    A list of all files that are members of filenames or descended from a\n    directory in filenames\n  \"\"\"\n  expanded = set()\n  for filename in filenames:\n      if not os.path.isdir(filename):\n        expanded.add(filename)\n        continue\n\n      for root, _, files in os.walk(filename):\n        for loopfile in files:\n          fullname = os.path.join(root, loopfile)\n          if fullname.startswith('.' + os.path.sep):\n            fullname = fullname[len('.' + os.path.sep):]\n          expanded.add(fullname)\n\n  filtered = []\n  for filename in expanded:\n      if os.path.splitext(filename)[1][1:] in GetAllExtensions():\n          filtered.append(filename)\n\n  return filtered\n\ndef _FilterExcludedFiles(filenames):\n  \"\"\"Filters out files listed in the --exclude command line switch. File paths\n  in the switch are evaluated relative to the current working directory\n  \"\"\"\n  exclude_paths = [os.path.abspath(f) for f in _excludes]\n  return [f for f in filenames if os.path.abspath(f) not in exclude_paths]\n\ndef main():\n  filenames = ParseArguments(sys.argv[1:])\n  backup_err = sys.stderr\n  try:\n    # Change stderr to write with replacement characters so we don't die\n    # if we try to print something containing non-ASCII characters.\n    sys.stderr = codecs.StreamReader(sys.stderr, 'replace')\n\n    _cpplint_state.ResetErrorCounts()\n    for filename in filenames:\n      ProcessFile(filename, _cpplint_state.verbose_level)\n    _cpplint_state.PrintErrorCounts()\n\n    if _cpplint_state.output_format == 'junit':\n      sys.stderr.write(_cpplint_state.FormatJUnitXML())\n\n  finally:\n    sys.stderr = backup_err\n\n  sys.exit(_cpplint_state.error_count > 0)\n\n\nif __name__ == '__main__':\n  main()\n"
  },
  {
    "path": "scripts/python/cpplint_wrap.py",
    "content": "## wraps local cpplint to produce verbose output without code harness\nimport cpplint\nimport sys\n\ndef main():\n    FILTERS=('cpplint --verbose=0 --linelength=100 --filter=-legal/copyright,-build/include_order,'\n    '-build/c++11,-build/namespaces,-build/class,-build/include,-build/include_subdir,-readability/inheritance,'\n    '-readability/function,-readability/casting,-readability/namespace,-readability/alt_tokens,'\n    '-readability/braces,-readability/fn_size,-whitespace/comments,-whitespace/braces,-whitespace/empty_loop_body,'\n    '-whitespace/indent,-whitespace/newline,-runtime/explicit,-runtime/arrays,-runtime/int,-runtime/references,'\n    '-runtime/string,-runtime/operator,-runtime/printf').split(' ')\n\n    result = False\n    files = sys.argv[1:]\n    for loopfile in files:\n        newargs = FILTERS + [loopfile]\n        sys.argv = newargs\n\n        try:\n            cpplint.main()\n        except SystemExit as e:\n            last_result = e.args[0]\n            result = result or last_result\n            if (last_result):\n                write_code_lines(loopfile)\n    sys.exit(result)\n\ndef write_code_lines(filename):\n    with open(filename, 'r') as f:\n        linenum = 1\n        for line in f:\n            if (not '// by md-split' in line):\n                sys.stdout.write('%3d  %s' % (linenum, line))\n            linenum += 1\n\nif __name__ == '__main__':\n  main()\n"
  },
  {
    "path": "scripts/python/md-split.py",
    "content": "#! /usr/bin/env python\n\n# A script that splits a Markdown file into plain text (for spell checking) and c++ files.\n\n\nfrom __future__ import absolute_import, print_function, unicode_literals\n\nimport os\nimport shutil\nimport io\nimport argparse\n\nimport re\nTAG_REGEX = re.compile(r'(<!--.*?-->|<[^>]*>)')\nNAMED_A_TAG_REGEX = re.compile(r'.*name ?= ?\"([^\"]*)\"')\n\ndef main():\n    \"\"\"\n    This script ended up ugly, so in case somebody wants to reimplement, here is the spec that grew by time.\n\n    What it should do it take a markdown file, and split it into more files. A targetfile should have the same\n    number of lines as the original, with source code snippets and markdown non-words removed, for spell-checking.\n\n    Each code snipped should go into a separate file in codedir.\n\n    Each code snipped should get additional C++ code around it to help compile the line in context, with\n    some heuristic guessing of what is needed around. The wrapping code should have a token in each line allowing\n    other tools to filter out these lines\n\n    The name for each file chosen consists os the section id in the markdown document, a counter for the snippet inside the section.\n\n    Snippets without code (only comments) or containing lines starting with ??? should not yeld files,\n    but the counter for naming snippets should still increment.\n    \"\"\"\n    parser = argparse.ArgumentParser(description='Split md file into plain text and code blocks')\n    parser.add_argument('sourcefile',\n                        help='which file to read')\n    parser.add_argument('targetfile',\n                        help='where to put plain text')\n    parser.add_argument('codedir',\n                        help='where to put codeblocks')\n    args = parser.parse_args()\n\n    # ensure folder exists\n    if not os.path.exists(args.codedir):\n        os.makedirs(args.codedir)\n\n\n    if os.path.exists(args.targetfile):\n        os.remove(args.targetfile)\n\n    code_block_index = 0\n    last_header = ''\n    linenum = 0\n    with io.open(args.sourcefile, 'r') as read_filehandle:\n        with io.open(args.targetfile, 'w') as text_filehandle:\n            for line in read_filehandle:\n                linenum += 1\n                indent_depth = is_code(line)\n                if indent_depth:\n                    (line, linenum) = process_code(read_filehandle,\n                                                    text_filehandle,\n                                                    line, linenum,\n                                                    args.sourcefile, args.codedir,\n                                                    last_header, code_block_index,\n                                                    indent_depth)\n                    code_block_index += 1\n                # reach here either line was not code, or was code\n                # and we dealt with n code lines\n                if indent_depth < 4 or not is_code(line, indent_depth):\n                    # store header id for codeblock\n                    section_id = get_marker(line)\n                    if section_id is not None:\n                        code_block_index = 0\n                        last_header = section_id\n                    sline = stripped(line)\n                    text_filehandle.write(sline)\n\n    assert line_length(args.sourcefile) == line_length(args.targetfile)\n\n\ndef process_code(read_filehandle, text_filehandle, line, linenum, sourcefile, codedir, name, index, indent_depth):\n    fenced = (line.strip() == '```')\n    if fenced:\n        try:\n            line = read_filehandle.readLine()\n            linenum += 1\n            text_filehandle.write('\\n')\n        except StopIteration:\n            return ('', linenum)\n    start_linenum = linenum\n    has_actual_code = False\n    has_question_marks = False\n    linebuffer = []\n    while ((fenced and line.strip() != '```') or (not fenced and is_inside_code(line, indent_depth))):\n        # copy comments to plain text for spell check\n        comment_idx = line.find('//')\n        no_comment_line = line\n        if comment_idx >= 0:\n            no_comment_line = line[:comment_idx].strip()\n            text_filehandle.write(line[comment_idx + 2:])\n        else:\n            # write empty line so line numbers stay stable\n            text_filehandle.write('\\n')\n\n        if (not has_actual_code\n            and not line.strip().startswith('//')\n            and not line.strip().startswith('???')\n            and not line.strip() == ''):\n            has_actual_code = True\n\n        if (not line.strip() == '```'):\n            if ('???' == no_comment_line or '...' == no_comment_line):\n                has_question_marks = True\n            linebuffer.append(dedent(line, indent_depth) if not fenced else line)\n        try:\n            line = read_filehandle.readline()\n            linenum += 1\n        except StopIteration:\n            line = ''\n            break\n    codefile = os.path.join(codedir, '%s%s.cpp' % (name, index))\n    if fenced:\n        text_filehandle.write('\\n')\n\n    if (has_actual_code and not has_question_marks):\n        linebuffer = clean_trailing_newlines(linebuffer)\n        write_with_harness(codefile, sourcefile, start_linenum, linebuffer)\n    return (line, linenum)\n\n\ndef clean_trailing_newlines(linebuffer):\n    result = []\n    code_started = False\n    linebuffer.reverse()\n    for line in linebuffer:\n        if not code_started and line == '\\n':\n            continue\n        code_started = True\n        result.append(line)\n    result.reverse()\n    return result\n\n\ndef write_with_harness(codefile, sourcefile, start_linenum, linebuffer):\n    '''write output with additional lines to make code likely compilable'''\n    # add commonly used headers, so that lines can likely compile.\n    # This is work in progress, the main issue remains handling class\n    # declarations in in-function code differently\n    with io.open(codefile, 'w') as code_filehandle:\n        code_filehandle.write('''\\\n#include<stdio.h>      // by md-split\n#include<stdlib.h>     // by md-split\n#include<tuple>        // by md-split\n#include<utility>      // by md-split\n#include<limits>       // by md-split\n#include<functional>   // by md-split\n#include<string>       // by md-split\n#include<map>          // by md-split\n#include<iostream>     // by md-split\n#include<vector>       // by md-split\n#include<algorithm>    // by md-split\n#include<memory>       // by md-split\nusing namespace std;   // by md-split\n// %s : %s\n''' % (sourcefile, start_linenum))\n        # TODO: if not toplevel code, wrap inside class\n        for codeline in linebuffer:\n            code_filehandle.write(codeline)\n\n\ndef is_code(line, indent_depth = 4):\n    '''returns the indent depth, 0 means not code in markup'''\n    if line.startswith(' ' * indent_depth):\n        return len(line) - len(line.lstrip(' '))\n    return 0\n\ndef is_inside_code(line, indent_depth):\n    return is_code(line, indent_depth) > 0 or line.strip() == ''\n\ndef stripped(line):\n    # Remove well-formed html tags, fixing mistakes by legitimate users\n    sline = TAG_REGEX.sub('', line)\n    sline = re.sub(r'[()[\\]#*]', ' ', line)\n    return sline\n\ndef dedent(line, indent_depth):\n    if line.startswith(' ' * indent_depth):\n        return line[indent_depth:]\n    if line.startswith('\\t'):\n        return line[1:]\n    return line\n\ndef get_marker(line):\n    matchlist = TAG_REGEX.findall(line)\n    if matchlist:\n        namematch = NAMED_A_TAG_REGEX.match(line)\n        if namematch:\n            return namematch.group(1) # group 0 is full match\n\n    return None\n\ndef line_length(filename):\n    return sum(1 for line in open(filename))\n\nif __name__ == '__main__':\n    main()\n"
  },
  {
    "path": "talks/README.md",
    "content": "The guidelines were introduced during a number of talks at [CppCon](http://cppcon.org) 2015.\nHere are video recordings of those talks:\n\n- [Keynote: Writing Good C++ 14 (Bjarne Stroustrup)](https://www.youtube.com/watch?t=9&v=1OEu9C51K2A)\n- [Writing good C++ 14 By Default (Herb Sutter)](https://www.youtube.com/watch?v=hEx5DNLWGgA])\n- [Large Scale C++ With Modules: What You Should Know (Gabriel Dos Reis)](https://www.youtube.com/watch?v=RwdQA0pGWa4)\n- [Contracts for Dependable C++ (Gabriel Dos Reis)](https://www.youtube.com/watch?v=Hjz1eBx91g8)\n- [Static analysis and C++: more than lint (Neil MacIntosh)](https://www.youtube.com/watch?v=rKlHvAw1z50)\n- [A few good types: Evolving `array_view` and `string_view` for safe C++ code (Neil MacIntosh)](https://www.youtube.com/watch?v=C4Z3c4Sv52U) \n\nThe YouTube channel for [CppCon](http://cppcon.org) is [here](https://www.youtube.com/channel/UCMlGfpWw-RUdWX_JbLCukXg).\n\nSlides from the talks are available in this folder.\n"
  }
]