Programmer's ROM - The Computer Language Library/programmersrom.iso/ada/spell/spell2.src

Text File | 1988-05-03 | 748.4 KB | 53,335 lines

-------- SIMTEL20 Ada Software Repository Prologue ------------
--                                                           -*
-- Unit name    : Spelling Checker
-- Version      : 1.0
-- Contact      : Lt. Colonel Falgiano
--              : ESD/SCW
--              : Hanscom AFB, MA  01731
-- Author       : John Foreman
--              : Texas Instruments, Inc.
--              : P.O. Box 801 MS 8007
--              : McKinney, TX  75069
-- DDN Address  :
-- Copyright    : (c) 1985 Texas Instruments, Inc.
-- Date created : 14 December 1984
-- Release date : March 1985
-- Last update  :
--                                                           -*
---------------------------------------------------------------
--                                                           -*
-- Keywords     :
----------------:
--
-- Abstract     : Procedure  SPELLER is an interactive spell
----------------: checking utility.  The "default" format shall
----------------: be interactive.  Options allow the user to
----------------: *enable auxiliary dictionary search
----------------: *merge two or more dictionaries together
----------------: *list the contents of a specified dictionary
----------------: *execute in batch mode
----------------: *generate an output file containing all suspect
----------------:  words
----------------: *disable the MASTER dictionary and or enable
----------------:  the ACRONYM dictionary
----------------: This procedure establishes the first level user
----------------: interface.  From this level the user will be
----------------: able to access the HELP facility, merge two or
----------------: more dictionaries, list out a dictionary and
----------------: begin the spell checking process of a document.
----------------:
----------------: This tool was developed as a precursor for
----------------: the WMCCS Information System (WIS).  An
----------------: executable version of the tool has been
----------------: demonstrated.  This source code has sub-
----------------: sequently been recompiled but has not under-
----------------: gone extensive testing.
----------------:
--                                                           -*
------------------ Revision history ---------------------------
--                                                           -*
-- DATE         VERSION AUTHOR                  HISTORY
-- 03/85          1.0   John Foreman            Initial Release
--                                                           -*
------------------ Distribution and Copyright -----------------
--                                                           -*
-- This prologue must be included in all copies of this software.
--
-- This software is copyright by the author.
--
-- This software is released to the Ada community.
-- This software is released to the Public Domain (note:
--   software released to the Public Domain is not subject
--   to copyright protection).
-- Restrictions on use or distribution:  NONE
--                                                           -*
----------------- Disclaimer ----------------------------------
--                                                           -*
-- This software and its documentation are provided "AS IS" and
-- without any expressed or implied warranties whatsoever.
--
-- No warranties as to performance, merchantability, or fitness
-- for a particular purpose exist.
--
-- Because of the diversity of conditions and hardware under
-- which this software may be used, no warranty of fitness for
-- a particular purpose is offered.  The user is advised to
-- test the software thoroughly before relying on it.  The user
-- must assume the entire risk and liability of using this
-- software.
--
-- In no event shall any person or organization of people be
-- held responsible for any direct, indirect, consequential
-- or inconsequential damages or lost profits.
--                                                          -*
----------------- END-PROLOGUE -------------------------------
::::::::::
speller_src.dis
::::::::::
@SPELLER_CMP.DIS
SPELLER_MASTER.DCT
SPELLER_ACRONYM.DCT
::::::::::
SPELLER_CMP.DIS
::::::::::
--compilation order for Spelling Corrector tool
-- The names of the following files were changed to maintain
-- the first 9 characters as unique:
--    Old Name            New Name
--    COMMAND_LINE_HANDLER.ADA    CLINE_HANDLER.ADA
--    COMMAND_LINE_IFACE.ADA        CLINE_IFACE.ADA
--    GET_USER_INFO_BODY.ADA        GET_UI_BODY.ADA
--    GET_USER_INFO_SPEC.ADA        GET_UI_SPEC.ADA
--    LINKED_LIST_BODY.ADA        LLIST_BODY.ADA
--    LINKED_LIST_SPEC.ADA        LLIST_SPEC.ADA
--    UTILITIES_BODY.ADA        UTIL_BODY.ADA
--    UTILITIES_SPEC.ADA        UTIL_SPEC.ADA
--    CORRECTOR_SPEC.ADA        CORR_SPEC.ADA
--    CORRECTOR_BODY.ADA        CORR_BODY.ADA
--
CHARACTER_SET.ADA
EQUALITY_OPERATOR.ADA
MACHINE_DEPEND_SPEC.ADA
TOKEN_DEFINITION.ADA
LLIST_SPEC.ADA
LLIST_BODY.ADA
COUNT_STATISTICS.ADA
TERMINAL_SPEC.ADA
TERMINAL_BODY.ADA
MANAGER_SPEC.ADA
MANAGER_BODY.ADA
DH_SPEC.ADA
DH_BODY.ADA
RTS.ADA
WORD_LIST_SPEC.ADA
WORD_LIST_BODY.ADA
HELPINFO_SPEC.ADA
HELPINFO_BODY.ADA
HELP_SPEC.ADA
HELP_BODY.ADA
HELP_DIS_ALL.ADA
HELP_EXIT.ADA
HELP_FIND.ADA
HELP_GET.ADA
HELP_INIT.ADA
HELP_ME.ADA
HELP_MENU.ADA
HELP_PROMPT.ADA
HELP_RESET.ADA
HELP_TEXT.ADA
HELP_FILE_SPEC.ADA
HELP_FILE_BODY.ADA
GET_UI_SPEC.ADA
GET_UI_BODY.ADA
UTIL_SPEC.ADA
UTIL_BODY.ADA
CORR_SPEC.ADA
CORR_BODY.ADA
PROCESS_SPEC.ADA
PROCESS_BODY.ADA
CLINE_HANDLER.ADA
CLINE_IFACE.ADA
SPELLER.ADA
::::::::::
CHARACTER_SET.ADA
::::::::::
--
-- Components Package CHARACTER_SET
-- by Richard Conn, TI Ada Technology Branch
-- Version 1.1, Date 25 Feb 85
-- Version 1.0, Date 13 Feb 85
--
package CHARACTER_SET is

--
-- These routines test for the following subsets of ASCII
--
-- Routine              Subset tested for
-- =======              =================
-- ALPHA                'a'..'z' | 'A'..'Z'
-- ALPHA_NUMERIC        ALPHA | '0'..'9'
-- CONTROL              < ' ' | DEL
-- DIGIT                '0'..'9'
-- GRAPHIC              ' ' < ch < DEL (does not include space)
-- HEXADECIMAL          DIGIT | 'A'..'F' | 'a'..'f'
-- LOWER                'a'..'z'
-- PRINTABLE            GRAPHIC | ' '
-- PUNCTUATION          GRAPHIC and not ALPHA_NUMERIC
-- SPACE                HT | LF | VT | FF | CR | ' '
-- UPPER                'A'..'Z'
--
    function IS_ALPHA         (CH : CHARACTER) return BOOLEAN;
    function IS_ALPHA_NUMERIC (CH : CHARACTER) return BOOLEAN;
    function IS_CONTROL       (CH : CHARACTER) return BOOLEAN;
    function IS_DIGIT         (CH : CHARACTER) return BOOLEAN;
    function IS_GRAPHIC       (CH : CHARACTER) return BOOLEAN;
    function IS_HEXADECIMAL   (CH : CHARACTER) return BOOLEAN;
    function IS_LOWER         (CH : CHARACTER) return BOOLEAN;
    function IS_PRINTABLE     (CH : CHARACTER) return BOOLEAN;
    function IS_PUNCTUATION   (CH : CHARACTER) return BOOLEAN;
    function IS_SPACE         (CH : CHARACTER) return BOOLEAN;
    function IS_UPPER         (CH : CHARACTER) return BOOLEAN;

--
-- These routines convert characters and strings to upper- or lower-case
--
    function  TO_LOWER (CH : CHARACTER) return CHARACTER;
    procedure TO_LOWER (CH : in out CHARACTER);
    procedure TO_LOWER (STR : in out STRING);
    function  TO_UPPER (CH : CHARACTER) return CHARACTER;
    procedure TO_UPPER (CH : in out CHARACTER);
    procedure TO_UPPER (STR : in out STRING);

--
-- These routines return the names of the control characters
--
    subtype CONTROL_CHARACTER_NAME_2 is STRING (1 .. 2);
    subtype CONTROL_CHARACTER_NAME_3 is STRING (1 .. 3);
--
    function CC_NAME_2 (CH : CHARACTER) return CONTROL_CHARACTER_NAME_2;
    function CC_NAME_3 (CH : CHARACTER) return CONTROL_CHARACTER_NAME_3;


end CHARACTER_SET;

package body CHARACTER_SET is

    function IS_ALPHA (CH : CHARACTER) return BOOLEAN is
    begin
    case CH is
        when 'a' .. 'z' =>
        return TRUE;
        when 'A' .. 'Z' =>
        return TRUE;
        when others =>
        return FALSE;
    end case;
    end IS_ALPHA;

    function IS_ALPHA_NUMERIC (CH : CHARACTER) return BOOLEAN is
    begin
    case CH is
        when 'a' .. 'z' =>
        return TRUE;
        when 'A' .. 'Z' =>
        return TRUE;
        when '0' .. '9' =>
        return TRUE;
        when others =>
        return FALSE;
    end case;
    end IS_ALPHA_NUMERIC;

    function IS_CONTROL (CH : CHARACTER) return BOOLEAN is
    begin
    return (CH in ASCII.NUL .. ASCII.US) or (CH = ASCII.DEL);
    end IS_CONTROL;

    function IS_DIGIT (CH : CHARACTER) return BOOLEAN is
    begin
    return (CH in '0' .. '9');
    end IS_DIGIT;

    function IS_GRAPHIC (CH : CHARACTER) return BOOLEAN is
    begin
    return (CH in '!' .. '~');
    end IS_GRAPHIC;

    function IS_HEXADECIMAL (CH : CHARACTER) return BOOLEAN is
    begin
    case CH is
        when '0' .. '9' =>
        return TRUE;
        when 'A' .. 'F' | 'a' .. 'f' =>
        return TRUE;
        when others =>
        return FALSE;
    end case;
    end IS_HEXADECIMAL;

    function IS_LOWER (CH : CHARACTER) return BOOLEAN is
    begin
    return (CH in 'a' .. 'z');
    end IS_LOWER;

    function IS_PRINTABLE (CH : CHARACTER) return BOOLEAN is
    begin
    return (CH in ' ' .. '~');
    end IS_PRINTABLE;

    function IS_PUNCTUATION (CH : CHARACTER) return BOOLEAN is
    begin
    if IS_GRAPHIC (CH) and (not IS_ALPHA_NUMERIC (CH)) then
        return TRUE;
    else
        return FALSE;
    end if;
    end IS_PUNCTUATION;

    function IS_SPACE (CH : CHARACTER) return BOOLEAN is
    begin
    case CH is
        when ASCII.HT =>
        return TRUE;
        when ASCII.LF =>
        return TRUE;
        when ASCII.VT =>
        return TRUE;
        when ASCII.FF =>
        return TRUE;
        when ASCII.CR =>
        return TRUE;
        when ' ' =>
        return TRUE;
        when others =>
        return FALSE;
    end case;
    end IS_SPACE;

    function IS_UPPER (CH : CHARACTER) return BOOLEAN is
    begin
    return (CH in 'A' .. 'Z');
    end IS_UPPER;

    function TO_LOWER (CH : CHARACTER) return CHARACTER is
    begin
    if IS_UPPER (CH) then
        return CHARACTER'VAL
             (CHARACTER'POS (CH) - CHARACTER'POS ('A') +
              CHARACTER'POS ('a'));
    else
        return CH;
    end if;
    end TO_LOWER;

    procedure TO_LOWER (CH : in out CHARACTER) is
    begin
    if IS_UPPER (CH) then
        CH := TO_LOWER (CH);
    end if;
    end TO_LOWER;

    procedure TO_LOWER (STR : in out STRING) is
    begin
    for I in STR'FIRST .. STR'LAST loop
        STR (I) := TO_LOWER (STR (I));
    end loop;
    end TO_LOWER;

    function TO_UPPER (CH : CHARACTER) return CHARACTER is
    begin
    if IS_LOWER (CH) then
        return CHARACTER'VAL
             (CHARACTER'POS (CH) - CHARACTER'POS ('a') +
              CHARACTER'POS ('A'));
    else
        return CH;
    end if;
    end TO_UPPER;

    procedure TO_UPPER (CH : in out CHARACTER) is
    begin
    if IS_LOWER (CH) then
        CH := TO_UPPER (CH);
    end if;
    end TO_UPPER;

    procedure TO_UPPER (STR : in out STRING) is
    begin
    for I in STR'FIRST .. STR'LAST loop
        STR (I) := TO_UPPER (STR (I));
    end loop;
    end TO_UPPER;

    --
    -- Note: ^c comes from a mapping between the characters @ and NUL to
    --       _ and US
    --
    function CC_NAME_2 (CH : CHARACTER) return CONTROL_CHARACTER_NAME_2 is
    NAME : CONTROL_CHARACTER_NAME_2;
    begin
    case CH is
        when ASCII.NUL =>  NAME := "^@";
        when ASCII.SOH =>  NAME := "^A";
        when ASCII.STX =>  NAME := "^B";
        when ASCII.ETX =>  NAME := "^C";
        when ASCII.EOT =>  NAME := "^D";
        when ASCII.ENQ =>  NAME := "^E";
        when ASCII.ACK =>  NAME := "^F";
        when ASCII.BEL =>  NAME := "^G";
        when ASCII.BS =>  NAME := "^H";
        when ASCII.HT =>  NAME := "^I";
        when ASCII.LF =>  NAME := "^J";
        when ASCII.VT =>  NAME := "^K";
        when ASCII.FF =>  NAME := "^L";
        when ASCII.CR =>  NAME := "^M";
        when ASCII.SO =>  NAME := "^N";
        when ASCII.SI =>  NAME := "^O";
        when ASCII.DLE =>  NAME := "^P";
        when ASCII.DC1 =>  NAME := "^Q";
        when ASCII.DC2 =>  NAME := "^R";
        when ASCII.DC3 =>  NAME := "^S";
        when ASCII.DC4 =>  NAME := "^T";
        when ASCII.NAK =>  NAME := "^U";
        when ASCII.SYN =>  NAME := "^V";
        when ASCII.ETB =>  NAME := "^W";
        when ASCII.CAN =>  NAME := "^X";
        when ASCII.EM =>  NAME := "^Y";
        when ASCII.SUB =>  NAME := "^Z";
        when ASCII.ESC =>  NAME := "^[";
        when ASCII.FS =>  NAME := "^\";
        when ASCII.GS =>  NAME := "^]";
        when ASCII.RS =>  NAME := "^^";
        when ASCII.US =>  NAME := "^_";
        when ASCII.DEL =>  NAME := "^`";
        when others =>
        NAME := "  ";
        NAME (2) := CH;
    end case;
    return NAME;
    end CC_NAME_2;

    function CC_NAME_3 (CH : CHARACTER) return CONTROL_CHARACTER_NAME_3 is
    NAME : CONTROL_CHARACTER_NAME_3;
    begin
    case CH is
        when ASCII.NUL =>  NAME := "NUL";
        when ASCII.SOH =>  NAME := "SOH";
        when ASCII.STX =>  NAME := "STX";
        when ASCII.ETX =>  NAME := "ETX";
        when ASCII.EOT =>  NAME := "EOT";
        when ASCII.ENQ =>  NAME := "ENQ";
        when ASCII.ACK =>  NAME := "ACK";
        when ASCII.BEL =>  NAME := "BEL";
        when ASCII.BS =>  NAME := "BS ";
        when ASCII.HT =>  NAME := "HT ";
        when ASCII.LF =>  NAME := "LF ";
        when ASCII.VT =>  NAME := "VT ";
        when ASCII.FF =>  NAME := "FF ";
        when ASCII.CR =>  NAME := "CR ";
        when ASCII.SO =>  NAME := "SO ";
        when ASCII.SI =>  NAME := "SI ";
        when ASCII.DLE =>  NAME := "DLE";
        when ASCII.DC1 =>  NAME := "DC1";
        when ASCII.DC2 =>  NAME := "DC2";
        when ASCII.DC3 =>  NAME := "DC3";
        when ASCII.DC4 =>  NAME := "DC4";
        when ASCII.NAK =>  NAME := "NAK";
        when ASCII.SYN =>  NAME := "SYN";
        when ASCII.ETB =>  NAME := "ETB";
        when ASCII.CAN =>  NAME := "CAN";
        when ASCII.EM =>  NAME := "EM ";
        when ASCII.SUB =>  NAME := "SUB";
        when ASCII.ESC =>  NAME := "ESC";
        when ASCII.FS =>  NAME := "FS ";
        when ASCII.GS =>  NAME := "GS ";
        when ASCII.RS =>  NAME := "RS ";
        when ASCII.US =>  NAME := "US ";
        when ASCII.DEL =>  NAME := "DEL";
        when others =>
        NAME := "   ";
        NAME (2) := CH;
    end case;
    return NAME;
    end CC_NAME_3;

end CHARACTER_SET;
::::::::::
EQUALITY_OPERATOR.ADA
::::::::::
generic
  type Operand_Type is limited private;
  with function "=" (Left, Right : Operand_Type) return Boolean;
package Equality_Operator is
--------------------------------------------------------------------------
-- Abstract   : This package enables one to declare a user-defined equality
--              operator for any type.  This package was obtained from
--                 Goodenough, John B.
--                 "On defining "=" in Ada,
--                 ACM Ada Letters, Vol. IV, Issue 4, 1985, pp. 27-31
--                 Association for Computing Machinery
--------------------------------------------------------------------------
  package Equals is
    function "=" (Left, Right : Operand_Type) return Boolean
           renames Equality_Operator."=";
  end Equals;
end Equality_Operator;
::::::::::
MACHINE_DEPEND_SPEC.ADA
::::::::::
----------------------------------------------------------------
--
-- Abstract     :  This package allows for the inputting of the
--              :  various machine dependent constraints which are
--              :  necessary to interface this tool with different
--              :  hardware components.
--
----------------------------------------------------------------

package MACHINE_DEPENDENCIES is

--declares and initializes the help file

    HELP_FILE            : constant STRING := "HELP_FILE.INI";

--declares and initializes the command file

    COMMAND_FILE         : constant STRING := "COMMAND_LINE.TXT";

--declares and initializes the master dictionary file

    MASTER_DICTIONARY    : constant STRING := "SPELLER_MASTER.DCT";

--declares and initializes the acronym dictionary file

    ACRONYM_DICTIONARY   : constant STRING := "SPELLER_ACRONYM.DCT";

    TEMP_FILE_NAME       : constant STRING := "???.MERGE.TMP";

    SCREEN_LENGTH        : constant := 24;

    SCREEN_WIDTH         : constant := 80;

    MAX_FILE_NAME_LENGTH : constant := 128;

    FILE_LINE_LENGTH     : constant := 256;

    INFO_FILE            : constant STRING := "SPELL_DATA.INI";

                                                    -- set output page
    OUTPUT_PAGE_WIDTH    : constant := 130; -- width to 130
                                                    -- columns

                                                    -- set output page
    OUTPUT_PAGE_LENGTH   : constant := 55;  -- length to 55 lines
                                                    -- per page.

end MACHINE_DEPENDENCIES;
::::::::::
TOKEN_DEFINITION.ADA
::::::::::
--
-- Token-Specific Information for the Spelling Checker
--
package TOKEN_DEFINITION is

--
-- Definition of a Token (Word)
--
    TOKEN_LENGTH : constant NATURAL := 25;  -- number of characters
    subtype TOKEN_STRING is STRING (1 .. TOKEN_LENGTH);
    type TOKEN_TYPE is
    record
        WORD   : TOKEN_STRING;
        LENGTH : NATURAL;
    end record;

--
-- Routine to Return Flag indicating if passed char is a special character
--
    function IS_SPECIAL_CHAR (CH : CHARACTER) return BOOLEAN;

end TOKEN_DEFINITION;

package body TOKEN_DEFINITION is

    SPECIAL_CHARS : constant STRING (1 .. 3) := "-'.";

    function IS_SPECIAL_CHAR (CH : CHARACTER) return BOOLEAN is
    begin
    for I in SPECIAL_CHARS'FIRST .. SPECIAL_CHARS'LAST loop
        if CH = SPECIAL_CHARS (I) then
        return TRUE;
        end if;
    end loop;
    return FALSE;
    end IS_SPECIAL_CHAR;

end TOKEN_DEFINITION;
::::::::::
LLIST_SPEC.ADA
::::::::::
generic
  type List_Element is private;
package Singly_Linked_List is
--------------------------------------------------------------------------
-- Abstract   : This package provides an abstraction for a singly linked
--              list.
--------------------------------------------------------------------------

  type List_Type is limited private;

  function Empty (List : List_Type) return Boolean;
--------------------------------------------------------------------------
-- Abstract   : Indicates whether the list contains any elements.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be queried.
--------------------------------------------------------------------------

  function Null_Node (List : List_Type) return Boolean;
--------------------------------------------------------------------------
-- Abstract   : Indicates whether the "current pointer" references an
--              element in the list.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be queried.
--------------------------------------------------------------------------

  function Head_Node (List : List_Type) return Boolean;
--------------------------------------------------------------------------
-- Abstract   : Indicates whether the "current pointer" references the
--              head of the list.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be queried.
--------------------------------------------------------------------------

  function Tail_Node (List : List_Type) return Boolean;
--------------------------------------------------------------------------
-- Abstract   : Indicates whether the "current pointer" references the
--              tail of the list.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be queried.
--------------------------------------------------------------------------

  function Current_Element (List : List_Type) return List_Element;
--------------------------------------------------------------------------
-- Abstract   : Returns the value of the element referenced by the
--              "current pointer".
--              Raises END_ERROR if NULL_NODE(LIST) = TRUE.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be queried.
--------------------------------------------------------------------------

  procedure First (List : in out List_Type);
--------------------------------------------------------------------------
-- Abstract   : Positions the "current pointer" at the head of the list
--              (even if the list is empty).
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be modified.
--------------------------------------------------------------------------

  procedure Next (List : in out List_Type);
--------------------------------------------------------------------------
-- Abstract   : Positions the "current pointer" at the next element in the
--              list.  After the last element in the list NULL_NODE(LIST)
--              becomes true.
--              Raises END_ERROR if NULL_NODE(LIST) = TRUE.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be modified.
--------------------------------------------------------------------------

  procedure Insert_After (List : in out List_Type; Element : List_Element);
--------------------------------------------------------------------------
-- Abstract   : Inserts an element after the "current pointer".
--              If NULL_NODE(LIST) = TRUE the element is appended after
--              the tail element of the list.
--------------------------------------------------------------------------
-- Parameters : LIST    - is the list to be modified.
--              ELEMENT - is the element to be inserted.
--------------------------------------------------------------------------

  procedure Insert_Before (List : in out List_Type; Element : List_Element);
--------------------------------------------------------------------------
-- Abstract   : Inserts an element before the "current pointer".
--              If NULL_NODE(LIST) = TRUE the element is prepended before
--              the head element of the list.
--------------------------------------------------------------------------
-- Parameters : LIST    - is the list to be modified.
--              ELEMENT - is the element to be inserted.
--------------------------------------------------------------------------

  procedure Delete_Element (List : in out List_Type);
--------------------------------------------------------------------------
-- Abstract   : Deletes the element referenced by the "current pointer"
--              from the list.  Upon deletion the "current pointer"
--              references the element after the deleted element.
--              Raises END_ERROR if NULL_NODE(LIST) = TRUE.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be modified.
--------------------------------------------------------------------------

  generic
    with procedure Transformation (Element : in out List_Element);
  procedure Modify (List : List_Type);
--------------------------------------------------------------------------
-- Abstract   : Permits modification of the element referenced by the
--              "current pointer" where the modification doesn't require
--              external values (e.g. incrementing a field of the element).
--              Raises END_ERROR if NULL_NODE(LIST) = TRUE.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be modified.
--------------------------------------------------------------------------

  generic
    type Update_Information is private;
    with procedure Transformation (Element     : in out List_Element;
                                   Information : Update_Information);
  procedure Update (List : List_Type; Information : Update_Information);
--------------------------------------------------------------------------
-- Abstract   : Permits modification of the element referenced by the
--              "current pointer" where the modification requires
--              external values (e.g. assigning a value to a field of
--              the element).
--              Raises END_ERROR if NULL_NODE(LIST) = TRUE.
--------------------------------------------------------------------------
-- Parameters : LIST        - is the list to be modified.
--              INFORMATION - is the data necessary for the modification.
--------------------------------------------------------------------------

  pragma Inline (Empty, Null_Node, Head_Node, Tail_Node, Current_Element);

  pragma Inline (Modify, Update);

  End_Error : exception;

private

  type Node;
  type Node_Access is access Node;
  type Node is
    record
      Element : List_Element;
      Next    : Node_Access;
    end record;

  type List_Type is
    record
      Head     : Node_Access;
      Tail     : Node_Access;
      Previous : Node_Access;
      Current  : Node_Access;
    end record;

end Singly_Linked_List;
::::::::::
LLIST_BODY.ADA
::::::::::
with Unchecked_Deallocation;
package body Singly_Linked_List is
--------------------------------------------------------------------------
-- Abstract   : This package provides an abstraction for a singly linked
--              list.
--------------------------------------------------------------------------
-- Assumptions:
--      The lists being manipulated must be in one of the following states
--      both before and after execution of any subprogram in the package:
--              (1) empty-list          -- Head = null, Tail = null,
--                                         Previous = null, Current = null
--              (2) beginning-of-list   -- Head /= null, Tail /= null
--                                         Previous = null, Current = Head
--              (3) inside-of-list      -- Head /= null, Tail /= null
--                                         Previous.Next = Current
--              (4) outside-of-list     -- Head /= null, Tail /= null
--                                         Previous = null, Current = null
----------------------------------------------------------------------

  function Empty (List : List_Type) return Boolean is
--------------------------------------------------------------------------
-- Abstract   : Indicates whether the list contains any elements.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be queried.
--------------------------------------------------------------------------
  begin
    return (List.Head = null);
  end Empty;

  function Null_Node (List : List_Type) return Boolean is
--------------------------------------------------------------------------
-- Abstract   : Indicates whether the "current pointer" references an
--              element in the list.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be queried.
--------------------------------------------------------------------------
  begin
    return (List.Current = null);
  end Null_Node;

  function Head_Node (List : List_Type) return Boolean is
--------------------------------------------------------------------------
-- Abstract   : Indicates whether the "current pointer" references the
--              head of the list.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be queried.
--------------------------------------------------------------------------
  begin
    return (List.Current = List.Head);
  end Head_Node;

  function Tail_Node (List : List_Type) return Boolean is
--------------------------------------------------------------------------
-- Abstract   : Indicates whether the "current pointer" references the
--              tail of the list.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be queried.
--------------------------------------------------------------------------
  begin
    return (List.Current = List.Tail);
  end Tail_Node;

  function Current_Element (List : List_Type) return List_Element is
--------------------------------------------------------------------------
-- Abstract   : Returns the value of the element referenced by the
--              "current pointer".
--              Raises END_ERROR if NULL_NODE(LIST) = TRUE.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be queried.
--------------------------------------------------------------------------
  begin
    if List.Current = null then
      raise End_Error;
    else
      return List.Current.Element;
    end if;
  end Current_Element;

  procedure First (List : in out List_Type) is
--------------------------------------------------------------------------
-- Abstract   : Positions the "current pointer" at the head of the list
--              (even if the list is empty).
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be modified.
--------------------------------------------------------------------------
  begin
    List.Previous := null;
    List.Current := List.Head;
  end First;

  procedure Next (List : in out List_Type) is
--------------------------------------------------------------------------
-- Abstract   : Positions the "current pointer" at the next element in the
--              list.  After the last element in the list NULL_NODE(LIST)
--              becomes true.
--              Raises END_ERROR if NULL_NODE(LIST) = TRUE.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be modified.
--------------------------------------------------------------------------
  begin
    if List.Current = null then
      raise End_Error;
    else
      if List.Current = List.Tail then
        List.Previous := null;
      else
        List.Previous := List.Current;
      end if;
      List.Current := List.Current.Next;
    end if;
  end Next;

  procedure Insert_After (List : in out List_Type; Element : List_Element) is
--------------------------------------------------------------------------
-- Abstract   : Inserts an element after the "current pointer".
--              If NULL_NODE(LIST) = TRUE the element is appended after
--              the tail element of the list.
--------------------------------------------------------------------------
-- Parameters : LIST    - is the list to be modified.
--              ELEMENT - is the element to be inserted.
--------------------------------------------------------------------------
  begin
    if List.Current = null then
      List.Current := List.Tail;
    end if;
    if Empty (List) then
      List.Head := new Node'(Element, null);
      List.Tail := List.Head;
      List.Previous := null;
      List.Current := List.Head;
    else
      declare
        New_Node : Node_Access := new Node'(Element, List.Current.Next);
      begin
        if List.Current = List.Tail then
          List.Tail := New_Node;
        end if;
        List.Previous := List.Current;
        List.Previous.Next := New_Node;
        List.Current := New_Node;
      end;
    end if;
  end Insert_After;

  procedure Insert_Before (List    : in out List_Type;
                           Element : List_Element) is
--------------------------------------------------------------------------
-- Abstract   : Inserts an element before the "current pointer".
--              If NULL_NODE(LIST) = TRUE the element is prepended before
--              the head element of the list.
--------------------------------------------------------------------------
-- Parameters : LIST    - is the list to be modified.
--              ELEMENT - is the element to be inserted.
--------------------------------------------------------------------------
  begin
    if List.Current = null then
      List.Current := List.Head;
    end if;
    if Empty (List) then
      List.Head := new Node'(Element, null);
      List.Tail := List.Head;
      List.Previous := null;
      List.Current := List.Head;
    elsif List.Current = List.Head then
      List.Head := new Node'(Element, List.Head);
      List.Previous := null;
      List.Current := List.Head;
    else
      List.Previous.Next := new Node'(Element, List.Current);
      List.Current := List.Previous.Next;
    end if;
  end Insert_Before;

  procedure Delete_Element (List : in out List_Type) is
--------------------------------------------------------------------------
-- Abstract   : Deletes the element referenced by the "current pointer"
--              from the list.  Upon deletion the "current pointer"
--              references the element after the deleted element.
--              Raises END_ERROR if NULL_NODE(LIST) = TRUE.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be modified.
--------------------------------------------------------------------------

    procedure Free is new Unchecked_Deallocation (Node, Node_Access);

  begin
    if List.Current = null then
      raise End_Error;
    elsif List.Current = List.Head then
      declare
        Next_Node : Node_Access := List.Head.Next;
      begin
        Free (List.Head);
        List.Head := Next_Node;
        if List.Head = null then
          List.Tail := null;
        end if;
        List.Current := List.Head;
      end;
    else
      if List.Current = List.Tail then
        List.Tail := List.Previous;
      end if;
      List.Previous.Next := List.Current.Next;
      Free (List.Current);
      List.Current := List.Previous.Next;
      if List.Current = null then
        List.Previous := null;
      end if;
    end if;
  end Delete_Element;

  procedure Modify (List : List_Type) is
--------------------------------------------------------------------------
-- Abstract   : Permits modification of the element referenced by the
--              "current pointer" where the modification doesn't require
--              external values (e.g. incrementing a field of the element).
--              Raises END_ERROR if NULL_NODE(LIST) = TRUE.
--------------------------------------------------------------------------
-- Parameters : LIST - is the list to be modified.
--------------------------------------------------------------------------
  begin
    if List.Current = null then
      raise End_Error;
    else
      Transformation (List.Current.Element);
    end if;
  end Modify;

  procedure Update (List : List_Type; Information : Update_Information) is
--------------------------------------------------------------------------
-- Abstract   : Permits modification of the element referenced by the
--              "current pointer" where the modification requires
--              external values (e.g. assigning a value to a field of
--              the element).
--              Raises END_ERROR if NULL_NODE(LIST) = TRUE.
--------------------------------------------------------------------------
-- Parameters : LIST        - is the list to be modified.
--              INFORMATION - is the data necessary for the modification.
--------------------------------------------------------------------------
  begin
    if List.Current = null then
      raise End_Error;
    else
      Transformation (List.Current.Element, Information);
    end if;
  end Update;

end Singly_Linked_List;
::::::::::
COUNT_STATISTICS.ADA
::::::::::
--
-- COUNT_STATISTICS by Richard Conn, TI Ada Technology Branch
-- 27 Feb 85
--
generic
    type STATISTIC is (<>);

package COUNT_STATISTICS is
--------------------------------------------------------------------------
-- Abstract   : COUNT_STATISTICS maintains counters which may be used
--               to keep track of the frequency of certain error
--               conditions, as enumerated in the type STATISTIC.  To
--               use this package, the routine INITIALIZE_COUNTERS will
--               clear all counters, the routine INCREMENT_COUNTER will
--               increment the indicated counter, and the routine
--               COUNT will return the value of the indicated counter.
--
--------------------------------------------------------------------------


    procedure INITIALIZE_COUNTERS;
--------------------------------------------------------------------------
-- Abstract   : This routine sets the values of all counters to zero.
--------------------------------------------------------------------------


    procedure INCREMENT_COUNTER (COUNTER : STATISTIC);
--------------------------------------------------------------------------
-- Abstract   : This routine increments the indicated counter.
--------------------------------------------------------------------------


    function COUNT (COUNTER : STATISTIC) return NATURAL;
--------------------------------------------------------------------------
-- Abstract   : This routine returns the value of the indicated counter.
--------------------------------------------------------------------------

end COUNT_STATISTICS;


package body COUNT_STATISTICS is

    COUNTERS : array (STATISTIC) of NATURAL;

    procedure INITIALIZE_COUNTERS is
    begin
    COUNTERS := (others => 0);
    end INITIALIZE_COUNTERS;

    procedure INCREMENT_COUNTER (COUNTER : STATISTIC) is
    begin
    COUNTERS (COUNTER) := COUNTERS (COUNTER) + 1;
    end INCREMENT_COUNTER;

    function COUNT (COUNTER : STATISTIC) return NATURAL is
    begin
    return COUNTERS (COUNTER);
    end COUNT;

begin
    INITIALIZE_COUNTERS;
end COUNT_STATISTICS;
::::::::::
TERMINAL_SPEC.ADA
::::::::::
with TEXT_IO;
package TERMINAL_INTERFACE is

    subtype COUNT_TYPE is TEXT_IO.COUNT;

--exception declarations

    STATUS_ERROR : exception renames TEXT_IO.STATUS_ERROR;
    MODE_ERROR   : exception renames TEXT_IO.MODE_ERROR;
    NAME_ERROR   : exception renames TEXT_IO.NAME_ERROR;
    USE_ERROR    : exception renames TEXT_IO.USE_ERROR;
    DEVICE_ERROR : exception renames TEXT_IO.DEVICE_ERROR;
    END_ERROR    : exception renames TEXT_IO.END_ERROR;
    DATA_ERROR   : exception renames TEXT_IO.DATA_ERROR;
    LAYOUT_ERROR : exception renames TEXT_IO.LAYOUT_ERROR;

-- line and page control

    procedure NEW_PAGE;

    procedure NEW_LINE (SPACING : TEXT_IO.POSITIVE_COUNT := 1)
                         renames TEXT_IO.NEW_LINE;

    function END_OF_LINE return BOOLEAN renames TEXT_IO.END_OF_LINE;

-- character input-output

    procedure GET (ITEM : out CHARACTER) renames TEXT_IO.GET;

    procedure PUT (ITEM : CHARACTER) renames TEXT_IO.PUT;

-- string input-output

    procedure GET (ITEM : out STRING) renames TEXT_IO.GET;

    procedure PUT (ITEM : STRING) renames TEXT_IO.PUT;

    procedure GET_LINE (ITEM : out STRING; LAST : out NATURAL)
                         renames TEXT_IO.GET_LINE;

    procedure PUT_LINE (ITEM : STRING) renames TEXT_IO.PUT_LINE;

    procedure SET_COL (TO : in TEXT_IO.POSITIVE_COUNT)
                            renames TEXT_IO.SET_COL;

end TERMINAL_INTERFACE;
::::::::::
TERMINAL_BODY.ADA
::::::::::
----------------------------------------------------------------
--
-- Abstract     :  This package body contains one procedure that
--              :  allows the clearing of the screen on a terminal
--              :  being used.
--
----------------------------------------------------------------

with MACHINE_DEPENDENCIES;
package body TERMINAL_INTERFACE is

----------------------------------------------------------------
--
-- Abstract     :  The screen is cleared by a call to TEXT_IO.
--              :  NEW_LINE with a parameter of the screen length.
--
----------------------------------------------------------------

  procedure NEW_PAGE is

  begin
    TEXT_IO.NEW_LINE(MACHINE_DEPENDENCIES.SCREEN_LENGTH);
  end NEW_PAGE;

end TERMINAL_INTERFACE;
::::::::::
MANAGER_SPEC.ADA
::::::::::
----------------------------------------------------------------
--
-- Abstract     :   This unit outlines the procedures and functions
--              :   contained in this package.  The visible section
--              :   provides the interfaces necessary for commun-
--              :   ication with the various subunits contained in
--              :   the package.
--              :
--              :   The package is concerned with the handling of the
--              :   data structures that are utilized for the storage of the
--              :   information, (words and acronyms), which is used
--              :   within the Spelling Corrector tool.
--
----------------------------------------------------------------

with TEXT_IO,
     TOKEN_DEFINITION;
package DICTIONARY_MANAGER is

--Establishes the types of dictionaries available
  type DICTIONARY_TYPE is (MASTER,ACRONYM,USER);

  type DICTIONARY_PTR  is private;

  subtype FILE_NAME_TYPE  is TEXT_IO.FILE_TYPE;

--A variable used to count the number of words loaded into a dictionary
--structure.  A routine must be installed to use this variable.
  WORD_COUNTER           : NATURAL;

  NO_MORE_WORDS          : exception; --raised when the NEXT_WORD
                                      --procedure can no longer return
                                      --the required number of words or
                                      --the NEXT_WORD procedure is called with a
                                      --word count of 0

  BAD_WORD               : exception; --An illegal word format
                                      --raised when the word is too short
                                      --or illegal characters are contained
                                      --in the first two characters of the
                                      --word input to the manager.

  DICTIONARY_ERROR       : exception; --A nonexistent dictionary
                                      --or dictionary error

  WORD_NOT_VALID         : exception; --A word not in the dictionary
                                      --raised in the DELETE_WORD procedure

  HARDWARE_FAILURE       : exception; --Failure of IO devices

-- The following procedures and functions are documented in the
-- package body (DICTIONARY_MANAGER)

  procedure CREATE_DICTIONARY(DICTIONARY_KIND : in DICTIONARY_TYPE;
                              DICTIONARY_IN : out DICTIONARY_PTR;
                              FILENAME : in STRING);

  procedure LIST_DICTIONARY(DICTIONARY : in DICTIONARY_PTR;
                            FILENAME : in STRING);

  procedure LIST_DICTIONARY(DICTIONARY : in DICTIONARY_PTR);

  procedure MERGE_DICTIONARY(DICTIONARY_A : in out DICTIONARY_PTR;
                             DICTIONARY_B : in out DICTIONARY_PTR;
                             INTO_DICTIONARY : out DICTIONARY_PTR);

  procedure ENABLE_DICTIONARY(DICTIONARY : in DICTIONARY_PTR);

  procedure INSERT_WORD(TOKEN : TOKEN_DEFINITION.TOKEN_TYPE;
                        INTO_DICTIONARY : in DICTIONARY_PTR);

  procedure DELETE_WORD(TOKEN : TOKEN_DEFINITION.TOKEN_TYPE;
                        FROM_DICTIONARY : in DICTIONARY_PTR);

  procedure DISABLE(DICTIONARY : in DICTIONARY_PTR);

  procedure DELETE_DICTIONARY(DICTIONARY : in out DICTIONARY_PTR);

  procedure TOKEN_IS_FOUND(IN_DICTIONARY : out DICTIONARY_PTR;
                           WORD : in TOKEN_DEFINITION.TOKEN_TYPE;
                           FOUND : out BOOLEAN);

  function GET_MASTER_DICTIONARY return DICTIONARY_PTR;

  function GET_ACRONYM_DICTIONARY return DICTIONARY_PTR;

  procedure INITIATOR(TOKEN : in TOKEN_DEFINITION.TOKEN_TYPE;
                      NUMBER : in POSITIVE);

  procedure NEXT_WORD(WORD : out TOKEN_DEFINITION.TOKEN_TYPE);

  function MORE return BOOLEAN;

  function ALTER(DICTIONARY : in DICTIONARY_PTR) return BOOLEAN;

private

  type WORD_RECORD;

  type WORD_RECORD_PTR is access WORD_RECORD;

  type WORD_RECORD is
    record
      TOKEN   : TOKEN_DEFINITION.TOKEN_TYPE;
      NEXT    : WORD_RECORD_PTR;
    end record;

  MAX_HASH_BUCKETS : constant POSITIVE := 101;

  subtype HASH_BUCKET_TYPE is POSITIVE
                              range POSITIVE'FIRST..MAX_HASH_BUCKETS;

  type DICTIONARY_HASH_STRUCTURE is array (HASH_BUCKET_TYPE)
                                    of WORD_RECORD_PTR;

  type DICTIONARY_RECORD;

  type DICTIONARY_PTR is access DICTIONARY_RECORD;

  type DICTIONARY_RECORD is
    record
      DICTIONARY_NAME : DICTIONARY_TYPE;
      ENABLED         : BOOLEAN := FALSE;
      HASH_TABLE      : DICTIONARY_HASH_STRUCTURE;
      NEXT_DICTIONARY : DICTIONARY_PTR;
      ALTER_FLAG      : BOOLEAN := FALSE;
    end record;

end DICTIONARY_MANAGER;
::::::::::
MANAGER_BODY.ADA
::::::::::
----------------------------------------------------------------
--
-- Abstract     :  This unit contains the actual code for the
--              :  various procedures and functions contained
--              :  within package DICTIONARY_MANAGER.  Each
--              :  section is documented separately.
--              :
--              :  The purpose of the package is to provide the
--              :  necessary management of the data structures
--              :  used in the Spelling Corrector tool.
--              :
----------------------------------------------------------------

with MACHINE_DEPENDENCIES,
     CHARACTER_SET,
     TOKEN_DEFINITION,
--   UNCHECKED_DEALLOCATION,
     TERMINAL_INTERFACE;
package body DICTIONARY_MANAGER is

--A pointer to the head of the dictionary list

  DICTIONARY_SEARCH_LIST : DICTIONARY_PTR;

--A pointer to an incomplete dictionary left by a storage error
--during creation.  To be used for deallocation when available.

  DEALLOCATION : DICTIONARY_PTR;

--Generic instaniations to be used when UNCHECKED_DEALLOCATION is available

--procedure FREE is new UNCHECKED_DEALLOCATION(WORD_RECORD,WORD_RECORD_PTR);
--procedure FREE_DICT is new UNCHECKED_DEALLOCATION
--                           (DICTIONARY_RECORD,DICTIONARY_PTR);

--Establishes the length of a word(token)

  TOKEN_LENGTH_RANGE : constant POSITIVE := TOKEN_DEFINITION.TOKEN_LENGTH;

--Establishes the minimum length of a word in the dictionary.  This length
--is also necessary for the hashing function and the correction algorithm.

  NECESSARY_LENGTH : constant NATURAL := 2;

--A subtype to allow passing of the length of a token as a parameter

  subtype TOKEN_LENGTH_TYPE is POSITIVE range 1..TOKEN_LENGTH_RANGE;

--Declarations necessary to create the global variables needed in the
--INITIATOR, NEXT_WORD and MORE subprograms.

  COUNT    : NATURAL;
  INDEX    : HASH_BUCKET_TYPE;
  WORD_PTR : WORD_RECORD_PTR;
  INIT_WORD: TOKEN_DEFINITION.TOKEN_TYPE;
  TEMP_PTR : DICTIONARY_PTR;

----------------------------------------------------------------
--
-- Abstract     :  This function provides a boolean value of true
--              :  if a particular dictionary structure has been
--              :  altered since it was loaded from a file.
--
----------------------------------------------------------------
--
-- Parameters   :  DICTIONARY - An in parameter consisting of an
--              :               access value to the structure in
--              :               question.
--
----------------------------------------------------------------

  function ALTER(DICTIONARY : in DICTIONARY_PTR) return BOOLEAN is

  begin
    if DICTIONARY = null
    then
      raise DICTIONARY_ERROR;
    else
      return DICTIONARY.ALTER_FLAG;
    end if;
  end ALTER;

----------------------------------------------------------------
--
-- Abstract     :  This function provides access to the Acronym
--              :  dictionary if that dictionary exists.  If the
--              :  dictionary does not exist a null access type
--              :  is returned.
--
----------------------------------------------------------------
--
-- Parameters   :  An access type to a Dictionary Record is
--              :  returned by this function.
--
----------------------------------------------------------------

  function GET_ACRONYM_DICTIONARY return DICTIONARY_PTR is

  begin
    if DICTIONARY_SEARCH_LIST = null
    then
      return null;
    elsif
      DICTIONARY_SEARCH_LIST.DICTIONARY_NAME = ACRONYM
      then
        return DICTIONARY_SEARCH_LIST;
      elsif
        ((DICTIONARY_SEARCH_LIST.DICTIONARY_NAME = MASTER) and
        (DICTIONARY_SEARCH_LIST.NEXT_DICTIONARY /= null))
        and then (DICTIONARY_SEARCH_LIST.NEXT_DICTIONARY.DICTIONARY_NAME
               = ACRONYM)
        then
          return DICTIONARY_SEARCH_LIST.NEXT_DICTIONARY;
    else
      return null;
    end if;
  end GET_ACRONYM_DICTIONARY;

----------------------------------------------------------------
--
-- Abstract     :  This function provides and access type to the
--              :  Master dictionary if the dictionary exists. If
--              :  the unit does not exist a null access type is
--              :  returned.
--
----------------------------------------------------------------
--
-- Parameters   :  An access type to a Dictionary record is re-
--              :  turned by this function.
--
----------------------------------------------------------------

  function GET_MASTER_DICTIONARY return DICTIONARY_PTR is

  begin
    if DICTIONARY_SEARCH_LIST = null
    then
      return DICTIONARY_SEARCH_LIST;
    elsif
      DICTIONARY_SEARCH_LIST.DICTIONARY_NAME = MASTER
      then
        return DICTIONARY_SEARCH_LIST;
    else
      return null;
    end if;
  end GET_MASTER_DICTIONARY;

----------------------------------------------------------------
--
-- Abstract     :  This function provides the numeric value
--              :  to provide access to one cell of an array of
--              :  access types.  The algorithm used was obtained
--              :  from "Communications of the ACM", Volume 23,
--              :  Number 12, pp. 681.  This information is contained
--              :  in an article by James L. Peteson, "Computer
--              :  Programs for Detecting and Correcting Spelling
--              :  Errors".
--
----------------------------------------------------------------
--
-- Parameters   :  FIRST_CHARACTER  - The first character of the
--              :                     word to be hashed.
--              :  SECOND_CHARACTER - The second character of the
--              :                     word to be hashed.
--              :  TOKEN_LENGTH     - The length of the word.
--              :                   - A subtype of positive numbers
--              :                     returned by the hashing function.
--              :
----------------------------------------------------------------

  function HASH_VALUE(FIRST_CHARACTER : in CHARACTER;
                      SECOND_CHARACTER : in CHARACTER;
                      TOKEN_LENGTH : in TOKEN_LENGTH_TYPE)
                      return HASH_BUCKET_TYPE is

    FIRST      : NATURAL := CHARACTER'POS(FIRST_CHARACTER);
    SECOND     : NATURAL := CHARACTER'POS(SECOND_CHARACTER);
    HOLD       : TOKEN_LENGTH_TYPE;
    HOLDER     : HASH_BUCKET_TYPE;

  begin
    if not(CHARACTER_SET.IS_ALPHA_NUMERIC(FIRST_CHARACTER) and
          (CHARACTER_SET.IS_ALPHA_NUMERIC(SECOND_CHARACTER) or
           TOKEN_DEFINITION.IS_SPECIAL_CHAR(SECOND_CHARACTER)))
    then
      raise BAD_WORD;
    else

--Convert to lower case

      if (FIRST_CHARACTER >= 'A') and (FIRST_CHARACTER <= 'Z')
      then
        FIRST := CHARACTER'POS(CHARACTER_SET.TO_LOWER(FIRST_CHARACTER));
      end if;
      if (SECOND_CHARACTER >= 'A') and (SECOND_CHARACTER <= 'Z')
      then
        SECOND := CHARACTER'POS(CHARACTER_SET.TO_LOWER(SECOND_CHARACTER));
      end if;

--The hashing function starts here

      if (TOKEN_LENGTH - 2) >= 9
      then
        HOLD := 9;
      else
        HOLD := TOKEN_LENGTH;
      end if;
      return HASH_BUCKET_TYPE(((10 * ((FIRST * 26) + SECOND) +
                             HOLD) rem 101) + 1);
    end if;
  end HASH_VALUE;

----------------------------------------------------------------
--
-- Abstract     :  This procedure disables a dictionary.  This
--              :  disablement is accomplished by changing a
--              :  boolean value contained in the Dictionary
--              :  record to false.
--
----------------------------------------------------------------
--
-- Parameters   :  DICTIONARY - An access type to a Dictionary
--              :               record passed from the calling
--              :               routine to facilitate access to
--              :               the structure.
--
----------------------------------------------------------------

  procedure DISABLE(DICTIONARY : in DICTIONARY_PTR) is

  begin
    if DICTIONARY = null
    then
      raise DICTIONARY_ERROR;
    else
      DICTIONARY.ENABLED := FALSE;
    end if;
  end DISABLE;

----------------------------------------------------------------
--
-- Abstract     :  This procedure enables a dictionary.  This is
--              :  accomplished by setting a boolean value contained
--              :  in the dictionary record to true.
--              :
--
----------------------------------------------------------------
--
-- Parameters   :  DICTIONARY - An access type to a Dictionary
--              :               record passed from the calling
--              :               routine to facilitate access of
--              :               the structure.
--
----------------------------------------------------------------

  procedure ENABLE_DICTIONARY(DICTIONARY : in DICTIONARY_PTR) is

  begin
    if DICTIONARY = null
    then
      raise DICTIONARY_ERROR;
    else
      DICTIONARY.ENABLED := TRUE;
    end if;
  end ENABLE_DICTIONARY;

----------------------------------------------------------------
--
-- Abstract     :  This procedure creates a dictionary.  The
--              :  dictionary is initialized and data from a
--              :  file is entered into the structure.
--              :
--
----------------------------------------------------------------
--
-- Parameters   :  DICTIONARY_KIND - A designation of the type of
--              :                    dictionary to be created.
--              :
--              :  DICTIONARY_IN   - An access type used as an out
--              :                    parameter for later access to the
--              :                    structure.
--              :
--              :  FILENAME        - A STRING variable passed as an
--              :                    in parameter which contains the
--              :                    name of the file which stores the
--              :                    data to be loaded in to the in-
--              :                    ternal dictionary structure.
--
----------------------------------------------------------------

  procedure CREATE_DICTIONARY(DICTIONARY_KIND : in DICTIONARY_TYPE;
                              DICTIONARY_IN : out DICTIONARY_PTR;
                              FILENAME : in STRING)
                              is

    TEMP_DICT : DICTIONARY_PTR := null;
    DICTIONARY : DICTIONARY_PTR;

--Declarations used in UNCHECKED_DEALLOCATION(commented out)

--  HOLD_PTR : WORD_RECORD_PTR;
--  REC_PTR   : WORD_RECORD_PTR;

----------------------------------------------------------------
--
-- Abstract     :  This procedure initializes the new dictionary
--              :  structure.  The actual creation of a dictionary
--              :  node takes place in this procedure.
--              :
--              :  This procedure is internal to CREATE_DICTIONARY
--              :  and uses variables declared in that procedure.
--
----------------------------------------------------------------

    procedure INIT_DICT is

      begin
        DICTIONARY := new DICTIONARY_RECORD;
        DICTIONARY.DICTIONARY_NAME := DICTIONARY_KIND;
      end INIT_DICT;

----------------------------------------------------------------
--
-- Abstract     :  This procedure loads the contents of a file into
--              :  a dictionary data structure.
--              :
--
----------------------------------------------------------------
--
-- Parameters   :  This procedure is internal to CREATE_DICTIONARY
--              :  and uses variables declared in that procedure.
--
----------------------------------------------------------------
--
-- Algorithm    :  The algorithm is to read from a file while there
--              :  is data in the file and to create an array of linked lists
--              :  of the data which is indexed by the value returned
--              :  by the HASH_VALUE function.
--
----------------------------------------------------------------

    procedure LOAD_DICT is

      INPUT     : STRING(1..80);
      THIS_WORD : TOKEN_DEFINITION.TOKEN_STRING;
      WORD_LENGTH : TOKEN_LENGTH_TYPE;
      TEMP_PTR : WORD_RECORD_PTR := null;
      NUMBER : NATURAL;
      FROM_DICTIONARY : TEXT_IO.FILE_TYPE;

--There is the possibility of running out of storage and thus raising
--a STORAGE_ERROR in this procedure.  There is no way of knowing how
--much space will be required for the dictionaries used.  The dictionary
--being created will be left intact at the point of the STORAGE_ERROR.
--The dictionary may be accessed by the access variable DEALLOCATION.
--When UNCHECKED_DEALLOCATION is included the code for deallocating the
--dictionary is included in the exception handler of this routine.

      begin

--A test variable to be used to count the number of words loaded into the
--data structure.

        WORD_COUNTER := 0;

        TEXT_IO.OPEN(file => FROM_DICTIONARY,
                     mode => TEXT_IO.IN_FILE,
                     name => FILENAME,
                     form => "");

--beginning of the actual loading algorithm

        while not(TEXT_IO.END_OF_FILE(FROM_DICTIONARY))
        loop
          loop

--This loop passes over words of less than necessary length

            TEXT_IO.GET_LINE(FROM_DICTIONARY,INPUT,NUMBER);
            if (NUMBER <= TOKEN_LENGTH_RANGE) and (NUMBER >= NECESSARY_LENGTH)
            then
              THIS_WORD := INPUT(1..TOKEN_LENGTH_RANGE);
              exit;
            end if;
          end loop;
          WORD_LENGTH := TOKEN_LENGTH_TYPE(NUMBER);

--The words are counted at this point.

          WORD_COUNTER := WORD_COUNTER + 1;
          if DICTIONARY.HASH_TABLE(HASH_VALUE(THIS_WORD(1),
                                   THIS_WORD(2),WORD_LENGTH))
                                   = null
          then
            DICTIONARY.HASH_TABLE(HASH_VALUE(THIS_WORD(1),
                                  THIS_WORD(2),WORD_LENGTH))
                                  := new WORD_RECORD'((THIS_WORD,WORD_LENGTH),
                                                     null);
          else
            TEMP_PTR := DICTIONARY.HASH_TABLE(HASH_VALUE
                                          (THIS_WORD(1),
                                          THIS_WORD(2),WORD_LENGTH));
            while TEMP_PTR.NEXT /= null loop
              TEMP_PTR := TEMP_PTR.NEXT;
            end loop;
            TEMP_PTR.NEXT := new WORD_RECORD'((THIS_WORD,WORD_LENGTH),null);
          end if;
        end loop;
        TEXT_IO.CLOSE(FROM_DICTIONARY);
    exception
      when STORAGE_ERROR => TEXT_IO.CLOSE(FROM_DICTIONARY);
                            DEALLOCATION := DICTIONARY;

--Code to deallocate storage, to be used when UNCHECKED_DEALLOCATION is
--included.
--                          for INDEX in 1..MAX_HASH_BUCKETS loop
--                            REC_PTR := DICTIONARY.HASH_TABLE(INDEX);
--                            while REC_PTR /= null loop
--                              HOLD_PTR := REC_PTR.NEXT;
--                              FREE(REC_PTR);
--                              REC_PTR := HOLD_PTR;
--                            end loop;
--                          end loop;
--                          FREE_DICT(DICTIONARY);

                            raise STORAGE_ERROR;
    end LOAD_DICT;

----------------------------------------------------------------
--
-- Abstract     :  This procedure places a dictionary in its
--              :  proper place in the Dictionary Search List.
--              :  The ordering is on the basis of Master, Acronym,
--              :  and the various User dictonaries.
--
----------------------------------------------------------------
--
-- Parameters   :  This routine is internal to CREATE_DICTIONARY
--              :  and uses the variables associated with that
--              :  routine.
--
----------------------------------------------------------------

    procedure INSERT_DICT is

    begin
      if DICTIONARY_SEARCH_LIST = null
      then
        DICTIONARY_SEARCH_LIST := DICTIONARY;
      elsif
        DICTIONARY.DICTIONARY_NAME = MASTER
        then
          DICTIONARY.NEXT_DICTIONARY := DICTIONARY_SEARCH_LIST;
          DICTIONARY_SEARCH_LIST := DICTIONARY;
        elsif
          DICTIONARY.DICTIONARY_NAME = ACRONYM
          and then DICTIONARY_SEARCH_LIST.DICTIONARY_NAME = MASTER
          then
            DICTIONARY.NEXT_DICTIONARY := DICTIONARY_SEARCH_LIST.
                                          NEXT_DICTIONARY;
            DICTIONARY_SEARCH_LIST.NEXT_DICTIONARY := DICTIONARY;
      else
        TEMP_DICT := DICTIONARY_SEARCH_LIST;
        while TEMP_DICT.NEXT_DICTIONARY /= null loop
          TEMP_DICT := TEMP_DICT.NEXT_DICTIONARY;
        end loop;
        TEMP_DICT.NEXT_DICTIONARY := DICTIONARY;
      end if;
    end INSERT_DICT;


--This is the main routine of CREATE_DICTIONARY

  begin

--The check for the existence of a Master or Acronym dictionary when
--the same type of dictionary exists.

    if DICTIONARY_SEARCH_LIST /= null
    then
      if ((DICTIONARY_KIND = MASTER) and
         (DICTIONARY_SEARCH_LIST.DICTIONARY_NAME = MASTER)) or
         ((DICTIONARY_KIND = ACRONYM) and
         (DICTIONARY_SEARCH_LIST.DICTIONARY_NAME = ACRONYM)) or
         (((DICTIONARY_KIND = ACRONYM) and
         (DICTIONARY_SEARCH_LIST.NEXT_DICTIONARY /= null)) and then
         (DICTIONARY_SEARCH_LIST.NEXT_DICTIONARY.DICTIONARY_NAME = ACRONYM))
      then
        raise DICTIONARY_ERROR;
      end if;
    end if;

--Start of the actual routine

    INIT_DICT;
    TERMINAL_INTERFACE.NEW_LINE;
    TERMINAL_INTERFACE.PUT("*** Creating a ");
    TERMINAL_INTERFACE.PUT(DICTIONARY_MANAGER.DICTIONARY_TYPE'IMAGE
                          (DICTIONARY_KIND));
    TERMINAL_INTERFACE.PUT(" dictionary from ");
    TERMINAL_INTERFACE.PUT(FILENAME);
    TERMINAL_INTERFACE.PUT_LINE(" ***");
    TERMINAL_INTERFACE.NEW_LINE;
    LOAD_DICT;
    INSERT_DICT;
    ENABLE_DICTIONARY(DICTIONARY);
    DICTIONARY_IN := DICTIONARY;
  exception
    when TEXT_IO.DEVICE_ERROR => raise HARDWARE_FAILURE;
  end CREATE_DICTIONARY;

----------------------------------------------------------------
--
-- Abstract     :  This procedure provides a listing of the
--              :  data contained in the internal dictionary
--              :  structure.  This data is listed to a file.
--              :
--
----------------------------------------------------------------
--
-- Parameters   :  DICTIONARY - An access variable to a dictionary
--              :               record.  This variable provides
--              :               the address of the dictionary to be
--              :               listed.
--              :  FILENAME   - A STRING variable used to access the
--              :               file to which the dictionary is listed.
--
----------------------------------------------------------------
--
-- Algorithm    :  The algorithm used is to output from each dictionary
--              :  cell the information contained within the linked
--              :  list headed by that cell.
--
----------------------------------------------------------------

  procedure LIST_DICTIONARY(DICTIONARY : in DICTIONARY_PTR;
                            FILENAME : in STRING) is

    TOKEN : WORD_RECORD_PTR;
    LIST_NAME : TEXT_IO.FILE_TYPE;
    FAIL : BOOLEAN;

  begin
    FAIL := FALSE;
    begin
      TEXT_IO.CREATE(file => LIST_NAME,
                     mode => TEXT_IO.OUT_FILE,
                     name => FILENAME,
                     form => "");
    exception
      when others => FAIL := TRUE;
    end;
    if FAIL
    then
      TEXT_IO.OPEN(file => LIST_NAME,
                   mode => TEXT_IO.OUT_FILE,
                   name => FILENAME,
                   form => "");
    end if;

--Start of the actual list dictionary

    if (DICTIONARY = null) or else (not(DICTIONARY.ENABLED))
    then
      raise DICTIONARY_ERROR;
    else

--The start of the outer loop

      for INDEX in 1..MAX_HASH_BUCKETS loop
        TOKEN := DICTIONARY.HASH_TABLE(INDEX);

--The start of the inner loop

        while TOKEN /= null loop
          TEXT_IO.PUT_LINE(LIST_NAME,TOKEN.TOKEN.WORD(1..TOKEN.TOKEN.LENGTH));
          TOKEN := TOKEN.NEXT;
        end loop;
      end loop;
      TEXT_IO.CLOSE(LIST_NAME);
    end if;
  exception
    when TEXT_IO.DEVICE_ERROR => raise HARDWARE_FAILURE;
  end LIST_DICTIONARY;

----------------------------------------------------------------
--
-- Abstract     :  This procedure provides a listing of the data
--              :  contained in the internal dictionary to the
--              :  terminal.
--              :
--
----------------------------------------------------------------
--
-- Parameters   :  DICTIONARY - An in parameter used to access the
--              :               dictionary structure to be listed.
--
----------------------------------------------------------------
--
-- Algorithm    :  This procedure is an overload of the previous
--              :  LIST_DICTIONARY procedure.  The algorithm is
--              :  the same with output to the terminal.
--
----------------------------------------------------------------

  procedure LIST_DICTIONARY(DICTIONARY : in DICTIONARY_PTR) is

    TOKEN : WORD_RECORD_PTR;

  begin
    if (DICTIONARY = null) or else (not(DICTIONARY.ENABLED))
    then
      raise DICTIONARY_ERROR;
    else
      for INDEX in 1..MAX_HASH_BUCKETS loop
        TOKEN := DICTIONARY.HASH_TABLE(INDEX);
        while TOKEN /= null loop
          TERMINAL_INTERFACE.PUT_LINE(TOKEN.TOKEN.WORD(1..TOKEN.TOKEN.LENGTH));
          TOKEN := TOKEN.NEXT;
        end loop;
      end loop;
    end if;
  exception
    when TERMINAL_INTERFACE.DEVICE_ERROR => raise HARDWARE_FAILURE;
  end LIST_DICTIONARY;

----------------------------------------------------------------
--
-- Abstract     :  This procedure provides the ability to delete
--              :  a word from an existing dictionary.  The
--              :  dictionary must exist and be enabled.
--              :
--
----------------------------------------------------------------
--
-- Parameters   :  TOKEN     - A record containing the word to be
--              :              deleted and the length of the word.
--              :  FROM_DICTIONARY - An access variable disignating
--              :              the dictionary structure from which
--              :              the word is to be deleted.
--
----------------------------------------------------------------
--
-- Algorithm    :  Function HASH_VALUE is used to determine the proper
--              :  cell of the dictionary.  A linear search, comparing
--              :  on the length of the words, is used.  When the length
--              :  is matched a compare of the words is performed.  If
--              :  the word is found it is deleted.  If the word is not
--              :  found the list is searched from this point until a
--              :  new length match is found or until the end of the list
--              :  is found.  An exception is returned if the word can-
--              :  not be matched in the dictionary.
--
----------------------------------------------------------------

  procedure DELETE_WORD(TOKEN : in TOKEN_DEFINITION.TOKEN_TYPE;
                        FROM_DICTIONARY : in DICTIONARY_PTR) is

    TEMP_WORD_RECORD_PTR : WORD_RECORD_PTR;
    SAVE_WORD_RECORD_PTR : WORD_RECORD_PTR;
    WORD : TOKEN_DEFINITION.TOKEN_STRING := TOKEN.WORD;
    LENGTH : NATURAL := TOKEN.LENGTH;

  begin

--A check for improper word length

    if TOKEN.LENGTH < NECESSARY_LENGTH
    then
      raise BAD_WORD;
    end if;

--A check for a valid dictionary structure

    if (FROM_DICTIONARY = null) or else (not(FROM_DICTIONARY.ENABLED))
    then
      raise DICTIONARY_ERROR;
    else

--The actual search and delete algorithm begins here

      TEMP_WORD_RECORD_PTR := FROM_DICTIONARY.HASH_TABLE(HASH_VALUE(
                                       WORD(1),WORD(2),LENGTH));
      SAVE_WORD_RECORD_PTR := TEMP_WORD_RECORD_PTR;
      if TEMP_WORD_RECORD_PTR /= null
      then
        loop

--The length check

          while (TEMP_WORD_RECORD_PTR.TOKEN.LENGTH /= LENGTH) and
                (TEMP_WORD_RECORD_PTR.NEXT /= null) loop
            SAVE_WORD_RECORD_PTR := TEMP_WORD_RECORD_PTR;
            TEMP_WORD_RECORD_PTR := TEMP_WORD_RECORD_PTR.NEXT;
          end loop;

--The word match

          if TEMP_WORD_RECORD_PTR.TOKEN.WORD(1..TEMP_WORD_RECORD_PTR.TOKEN.
                                            LENGTH) = WORD(1..LENGTH)
          then

--The deletion

            if SAVE_WORD_RECORD_PTR = TEMP_WORD_RECORD_PTR
            then
              FROM_DICTIONARY.HASH_TABLE(HASH_VALUE(WORD(1),WORD(2),LENGTH))
                            := SAVE_WORD_RECORD_PTR.NEXT;

--Code to free storage not used upon deletion.

--            FREE(SAVE_WORD_RECORD_PTR);

              FROM_DICTIONARY.ALTER_FLAG := TRUE;
              exit;
            else
              SAVE_WORD_RECORD_PTR.NEXT := TEMP_WORD_RECORD_PTR.NEXT;

--Code to free storage not used upon deletion.

--            FREE(TEMP_WORD_RECORD_PTR);

              FROM_DICTIONARY.ALTER_FLAG := TRUE;
              exit;
            end if;
          elsif
            TEMP_WORD_RECORD_PTR.NEXT = null
            then
              raise WORD_NOT_VALID;
          else
             SAVE_WORD_RECORD_PTR := TEMP_WORD_RECORD_PTR;
             TEMP_WORD_RECORD_PTR := TEMP_WORD_RECORD_PTR.NEXT;
          end if;
        end loop;
      else

--The unfound word exception raised

        raise WORD_NOT_VALID;
      end if;
    end if;
  end DELETE_WORD;

----------------------------------------------------------------
--
-- Abstract     :  This procedure provides the ability to insert
--              :  a word into an existing dictionary.  The
--              :  dictionary must be enabled and must exist.
--              :
--
----------------------------------------------------------------
--
-- Parameters   :  TOKEN    -  An in parameter containing the word
--              :              to be inserted into the dictionary
--              :              structure.
--              :  INTO_DICTIONARY -  The access variable containing
--              :              the address of the dictionary structure.
--
----------------------------------------------------------------
--
-- Algorithm    :  The algorithm used in this procedure is similar to
--              :  the algorithm used in the DELETE_WORD procedure.
--              :  The search is the same.  Upon location of the word
--              :  an exit is performed in order not to duplicate the
--              :  word.  If the word is not located in the particular
--              :  cell's list it is appended to the end of the list.
--
----------------------------------------------------------------

  procedure INSERT_WORD(TOKEN : in TOKEN_DEFINITION.TOKEN_TYPE;
                        INTO_DICTIONARY : in DICTIONARY_PTR) is

    TEMP_WORD_RECORD_PTR : WORD_RECORD_PTR;
    SAVE_WORD_RECORD_PTR : WORD_RECORD_PTR;
    WORD : TOKEN_DEFINITION.TOKEN_STRING := TOKEN.WORD;
    LENGTH : NATURAL := TOKEN.LENGTH;

  begin

--A check for improper word length

    if TOKEN.LENGTH < NECESSARY_LENGTH
    then
      raise BAD_WORD;
    end if;

--A check for an invalid dictionary structure

    if (INTO_DICTIONARY = null) or else (not(INTO_DICTIONARY.ENABLED))
    then
      raise DICTIONARY_ERROR;
    else

--The actual insertion routine begins here

      TEMP_WORD_RECORD_PTR := INTO_DICTIONARY.HASH_TABLE(HASH_VALUE(WORD(1),
                                            WORD(2),LENGTH));
      if TEMP_WORD_RECORD_PTR = null
      then
        INTO_DICTIONARY.HASH_TABLE(HASH_VALUE(WORD(1),WORD(2),LENGTH))
                                := new WORD_RECORD'((WORD,LENGTH),null);
        INTO_DICTIONARY.ALTER_FLAG := TRUE;
      else
        loop

--The check for the length match

          while (TEMP_WORD_RECORD_PTR.TOKEN.LENGTH /= LENGTH) and
                (TEMP_WORD_RECORD_PTR.NEXT /= null) loop
            TEMP_WORD_RECORD_PTR := TEMP_WORD_RECORD_PTR.NEXT;
          end loop;

--The check for the word match

          if TEMP_WORD_RECORD_PTR.TOKEN.WORD(1..TEMP_WORD_RECORD_PTR.TOKEN.
                                          LENGTH) = WORD(1..LENGTH)
          then

--The exit if the word is found

            exit;
          elsif

--The insertion of the word

            TEMP_WORD_RECORD_PTR.NEXT = null
            then
              TEMP_WORD_RECORD_PTR.NEXT := new WORD_RECORD'((WORD,LENGTH),null);
              INTO_DICTIONARY.ALTER_FLAG := TRUE;
              exit;
            else
              TEMP_WORD_RECORD_PTR := TEMP_WORD_RECORD_PTR.NEXT;
            end if;
          end loop;
       end if;
    end if;
  end INSERT_WORD;

----------------------------------------------------------------
--
-- Abstract     :   This procedure verifies that the in parameters
--              :   are valid dictionary structures.  This procedure
--              :   is called by both the MERGE_DICTIONARY and the
--              :   DELETE_DICTIONARY procedures.
--
----------------------------------------------------------------
--
-- Parameters   :   DICTIONARY - The access variable containing
--              :   the address of the dictionary structure to
--              :   be checked.
--
----------------------------------------------------------------

  procedure CHECK_DICTIONARY(DICTIONARY : in DICTIONARY_PTR) is

    HOLD_DICTIONARY_PTR : DICTIONARY_PTR;
    TEMP_DICTIONARY_PTR : DICTIONARY_PTR;

  begin
    HOLD_DICTIONARY_PTR := null;
    TEMP_DICTIONARY_PTR := DICTIONARY_SEARCH_LIST;
    while (DICTIONARY /= TEMP_DICTIONARY_PTR) and
          (TEMP_DICTIONARY_PTR /= null) loop
      HOLD_DICTIONARY_PTR := TEMP_DICTIONARY_PTR;
      TEMP_DICTIONARY_PTR := TEMP_DICTIONARY_PTR.NEXT_DICTIONARY;
    end loop;
    if TEMP_DICTIONARY_PTR = null
    then
      raise DICTIONARY_ERROR;
    end if;
  end CHECK_DICTIONARY;

----------------------------------------------------------------
--
-- Abstract     :  A procedure to remove a dictionary from the
--              :  DICTIONARY_SEARCH_LIST.  This procedure is called
--              :  by both the MERGE_DICTIONARY and the DELETE_DICTIONARY
--              :  procedures.
--
----------------------------------------------------------------
--
-- Parameters   :  DICTIONARY - The access variable which addresses
--              :               the dictionary structure to be removed.
--
----------------------------------------------------------------

  procedure CHANGE_LIST(DICTIONARY : in DICTIONARY_PTR) is

    TEMP_DICTIONARY_PTR : DICTIONARY_PTR;
    HOLD_DICTIONARY_PTR : DICTIONARY_PTR;

  begin
    HOLD_DICTIONARY_PTR := null;
    TEMP_DICTIONARY_PTR := DICTIONARY_SEARCH_LIST;
    while (DICTIONARY /= TEMP_DICTIONARY_PTR) and
          (TEMP_DICTIONARY_PTR /= null) loop
      HOLD_DICTIONARY_PTR := TEMP_DICTIONARY_PTR;
      TEMP_DICTIONARY_PTR := TEMP_DICTIONARY_PTR.NEXT_DICTIONARY;
    end loop;
    if HOLD_DICTIONARY_PTR = null
    then
      DICTIONARY_SEARCH_LIST := DICTIONARY_SEARCH_LIST.NEXT_DICTIONARY;
    elsif
      TEMP_DICTIONARY_PTR = null
      then
        null;
    else
      HOLD_DICTIONARY_PTR.NEXT_DICTIONARY := TEMP_DICTIONARY_PTR.
                                             NEXT_DICTIONARY;
    end if;
  end CHANGE_LIST;

----------------------------------------------------------------
--
-- Abstract     :  This procedure allows for the deletion of a
--              :  dictionary pointer from the search list.  This
--              :  has the effect of deleting a dictionary structure.
--              :  This procedure is called from outside of the package.
--
----------------------------------------------------------------
--
-- Parameters   :  DICTIONARY - An in parameter of an access type
--              :               which is the address of the structure
--              :               to be removed from the search list.
--
----------------------------------------------------------------

  procedure DELETE_DICTIONARY(DICTIONARY : in out DICTIONARY_PTR) is

  begin
    if (DICTIONARY = null) or
       (DICTIONARY_SEARCH_LIST = null)
    then
      raise DICTIONARY_ERROR;
    else
      CHECK_DICTIONARY(DICTIONARY);
      CHANGE_LIST(DICTIONARY);

--Code to reclaim storage when UNCHECKED_DEALLOCATION is implemented.

--    for INDEX in 1..MAX_HASH_BUCKETS loop
--      REC_PTR := DICTIONARY.HASH_TABLE(INDEX);
--      while REC_PTR /= null loop
--        HOLD_PTR := REC_PTR.NEXT;
--        FREE(REC_PTR);
--        REC_PTR := HOLD_PTR;
--      end loop;
--    end loop;
--    FREE_DICT(DICTIONARY);
      DICTIONARY := null;
    end if;
  end DELETE_DICTIONARY;

----------------------------------------------------------------
--
-- Abstract     :  This procedure provides the function of finding
--              :  a token if it exists in the enabled dictionaries.
--              :
--              :
--
----------------------------------------------------------------
--
-- Parameters   :  IN_DICTIONARY -  An out parameter, access type
--              :                   to the dictionary structure containing the
--              :                   word, if it is located.
--              :  WORD          _  The word to be searched for and its length.
--              :  FOUND         -  A BOOLEAN value returned to
--              :                   indicate the status of the search.
--
----------------------------------------------------------------
--
-- Algorithm    :  The algorithm used searches for a length match
--              :  of the words.  If the length is matched the word
--              :  is compared and the appropriate actions taken.  If
--              :  the word is not found the rest of the list is searched
--              :  and each enabled dictionary is searched in its turn.
--              :  If no match is obtained the BOOLEAN is returned false
--              :  and the IN_DICTIONARY variable is returned null.
--
----------------------------------------------------------------

  procedure TOKEN_IS_FOUND(IN_DICTIONARY : out DICTIONARY_PTR;
                           WORD : in TOKEN_DEFINITION.TOKEN_TYPE;
                           FOUND : out BOOLEAN) is

    STRUCTURE_PTR : DICTIONARY_PTR := DICTIONARY_SEARCH_LIST;
    ELEMENT_PTR   : WORD_RECORD_PTR;
    TOKEN         : TOKEN_DEFINITION.TOKEN_STRING := WORD.WORD;
    TOKEN_LENGTH  : NATURAL := WORD.LENGTH;

  begin

--A check for improper word length

    if WORD.LENGTH < NECESSARY_LENGTH
    then
      raise BAD_WORD;
    end if;

--The dictionary list loop

    SEARCH:
    while STRUCTURE_PTR /= null loop
      if STRUCTURE_PTR.ENABLED
      then
        ELEMENT_PTR := STRUCTURE_PTR.HASH_TABLE(HASH_VALUE(TOKEN(1),TOKEN(2),
                                   TOKEN_LENGTH));
        if ELEMENT_PTR /= null
        then

--The cell list search loop

        loop

--The length compare

          while (ELEMENT_PTR.NEXT /= null) and
            (ELEMENT_PTR.TOKEN.LENGTH /= TOKEN_LENGTH) loop
            ELEMENT_PTR := ELEMENT_PTR.NEXT;
          end loop;

--The word compare

          if ELEMENT_PTR.TOKEN.WORD(1..ELEMENT_PTR.TOKEN.LENGTH) =
                           (TOKEN(1..TOKEN_LENGTH))
          then
            FOUND := TRUE;
            IN_DICTIONARY := STRUCTURE_PTR;
            exit SEARCH;
          elsif
            ELEMENT_PTR.NEXT = null
            then
              exit;
          else
            ELEMENT_PTR := ELEMENT_PTR.NEXT;
          end if;
        end loop;
        end if;
      end if;

--To the next dictionary structure

      STRUCTURE_PTR := STRUCTURE_PTR.NEXT_DICTIONARY;
    end loop SEARCH;
    if STRUCTURE_PTR = null
    then

--The not found actions

      FOUND := FALSE;
      IN_DICTIONARY := null;
    end if;
  end TOKEN_IS_FOUND;

----------------------------------------------------------------
--
-- Abstract     :  This procedure provides for the merging of
--              :  two dictionaries that are resident in memory.
--              :  A third dictionary is created and its address
--              :  returned to the calling procedure.
--
----------------------------------------------------------------
--
-- Parameters   :  DICTIONARY_A - An in out parameter with the address
--              :                 of the dictionary structure to be
--              :                 merged.
--              :  DICTIONARY_B - A second in out parameter with a
--              :                 structure address.
--              :  INTO_DICTIONARY -  An out parameter which will contain
--              :                 the address of the output of the merge.
--
----------------------------------------------------------------
--
-- Algorithm    :  The A and B dictionaries are merged into a third
--              :  Structure.  All words contained in every cell of
--              :  B are in turn matched against every word in the
--              :  corresponding cell of A.  If the word is matched
--              :  it is not added to the new structure.  If the word is not
--              :  matched it is placed in the new structure.  At the
--              :  end of each cell's list comparison the cell list
--              :  from the A dictionary is appended to the end of the
--              :  new structure's corresponding cell list.  At the time
--              :  of this appending only the words not found in the A
--              :  list are contained in the new structure.  The addition
--              :  of the A list completes the merge of a particular cell.
--              :  This process is repeated until all cells are merged.
--
----------------------------------------------------------------

  procedure MERGE_DICTIONARY(DICTIONARY_A : in out DICTIONARY_PTR;
                             DICTIONARY_B : in out DICTIONARY_PTR;
                             INTO_DICTIONARY : out DICTIONARY_PTR)
                             is

    NEW_LIST_PTR : WORD_RECORD_PTR;
    A_TEMP_PTR   : WORD_RECORD_PTR;
    B_TEMP_PTR   : WORD_RECORD_PTR;
    NEW_DICTIONARY      : DICTIONARY_PTR;
    HOLD_DICTIONARY_PTR : DICTIONARY_PTR;

  begin

--The check for a valid dictionary

    if ((DICTIONARY_A = null) or (DICTIONARY_B = null)) or else
       ((DICTIONARY_A.DICTIONARY_NAME = MASTER) or
       (DICTIONARY_B.DICTIONARY_NAME = ACRONYM) or
       (DICTIONARY_SEARCH_LIST = null) or
       (DICTIONARY_A.ENABLED = FALSE) or
       (DICTIONARY_B.ENABLED = FALSE) or
       (DICTIONARY_A.DICTIONARY_NAME = ACRONYM) or
       (DICTIONARY_B.DICTIONARY_NAME = MASTER))
    then
      raise DICTIONARY_ERROR;
    end if;

--The allocation of the new dictionary structure, STORAGE_ERROR
--could be raised at this point.

    NEW_DICTIONARY := new DICTIONARY_RECORD;
    NEW_DICTIONARY.DICTIONARY_NAME := USER;
    NEW_DICTIONARY.ENABLED := TRUE;
    CHECK_DICTIONARY(DICTIONARY_A);
    CHECK_DICTIONARY(DICTIONARY_B);

--The array cell loop

    for INDEX in 1..MAX_HASH_BUCKETS loop
      B_TEMP_PTR := DICTIONARY_B.HASH_TABLE(INDEX);
      NEW_LIST_PTR := NEW_DICTIONARY.HASH_TABLE(INDEX);

--The B dictionary cell loop

      while B_TEMP_PTR /= null loop
        A_TEMP_PTR := DICTIONARY_A.HASH_TABLE(INDEX);

--The A dictionary cell loop

        while A_TEMP_PTR /= null loop

--The word compare

          if (B_TEMP_PTR.TOKEN.LENGTH = A_TEMP_PTR.TOKEN.LENGTH) and then
             (B_TEMP_PTR.TOKEN.WORD(1..B_TEMP_PTR.TOKEN.LENGTH)
             = A_TEMP_PTR.TOKEN.WORD(1..A_TEMP_PTR.TOKEN.LENGTH))
          then

--The exit if found

            exit;
          else
            A_TEMP_PTR := A_TEMP_PTR.NEXT;
          end if;
        end loop;

--The insertion into the new list

        if A_TEMP_PTR = null
        then
          if NEW_DICTIONARY.HASH_TABLE(INDEX) = null
          then
            NEW_DICTIONARY.HASH_TABLE(INDEX) := B_TEMP_PTR;
            NEW_LIST_PTR := B_TEMP_PTR;
          else
            NEW_LIST_PTR.NEXT := B_TEMP_PTR;
            NEW_LIST_PTR := NEW_LIST_PTR.NEXT;
          end if;
        end if;
        B_TEMP_PTR := B_TEMP_PTR.NEXT;
      end loop;

--The appending of A to the end of the list

      if NEW_DICTIONARY.HASH_TABLE(INDEX) = null
      then
        NEW_DICTIONARY.HASH_TABLE(INDEX) := DICTIONARY_A.HASH_TABLE(INDEX);
      else
        NEW_LIST_PTR.NEXT := DICTIONARY_A.HASH_TABLE(INDEX);
      end if;
    end loop;

--Deletion of the merged dictionary structures from the search list

    CHANGE_LIST(DICTIONARY_A);
    CHANGE_LIST(DICTIONARY_B);

--The addition of the output structure to the search list

    if DICTIONARY_SEARCH_LIST /= null
    then
      HOLD_DICTIONARY_PTR := DICTIONARY_SEARCH_LIST;
      while HOLD_DICTIONARY_PTR.NEXT_DICTIONARY /= null loop
        HOLD_DICTIONARY_PTR := HOLD_DICTIONARY_PTR.NEXT_DICTIONARY;
      end loop;
      HOLD_DICTIONARY_PTR.NEXT_DICTIONARY := NEW_DICTIONARY;
    else
      DICTIONARY_SEARCH_LIST := NEW_DICTIONARY;
    end if;
    DICTIONARY_A := null;
    DICTIONARY_B := null;
    INTO_DICTIONARY := NEW_DICTIONARY;
  end MERGE_DICTIONARY;

----------------------------------------------------------------
--
-- Abstract     :  This function returns a positive BOOLEAN value
--              :  if a counter initiated in the procedure INITIATOR
--              :  is greater than zero.  This value is used to control
--              :  the number of possible corrections output.
--
----------------------------------------------------------------

  function MORE return BOOLEAN is

  begin
    return COUNT > 0;
  end MORE;

----------------------------------------------------------------
--
-- Abstract     :  This procedure is used to return a word to the
--              :  calling routine.  These words are obtained from
--              :  the enabled dictionary structures and resemble
--              :  a word that is to be corrected.
--
----------------------------------------------------------------
--
-- Parameters   : WORD - An out parameter containing the possible
--              :        correctly spelled word and its length.
--
----------------------------------------------------------------
--
-- Algorithm    :  The dictionary structure cells are searched for
--              :  closely matching words of the same length
--              :  until there are no more words available or the
--              :  function MORE returns a negative value.
--              :  The index of the cells containing the possible
--              :  correct words is a global variable and is
--              :  initialized in procedure INITIATOR with a value
--              :  obtained from the hashing function HASH_VALUE.
--
----------------------------------------------------------------

  procedure NEXT_WORD(WORD : out TOKEN_DEFINITION.TOKEN_TYPE) is

  begin
    loop

--The search for the possible word

      if (WORD_PTR /= null) and (COUNT > 0) and (TEMP_PTR.ENABLED)
      then
        if (WORD_PTR.TOKEN.LENGTH = INIT_WORD.LENGTH) and then
           ((WORD_PTR.TOKEN.WORD(1) = INIT_WORD.WORD(1)) and then
           (WORD_PTR.TOKEN.WORD(2) = INIT_WORD.WORD(2)))
        then

--The return of the possible correct word

          WORD := WORD_PTR.TOKEN;
          COUNT := COUNT - 1;
          WORD_PTR := WORD_PTR.NEXT;
          exit;
        else
          WORD_PTR := WORD_PTR.NEXT;
        end if;
      elsif

--The move to the next dictionary structure

       ((TEMP_PTR.NEXT_DICTIONARY /= null) and (COUNT > 0)) and then
       (TEMP_PTR.NEXT_DICTIONARY.ENABLED)
        then
          TEMP_PTR := TEMP_PTR.NEXT_DICTIONARY;
          WORD_PTR := TEMP_PTR.HASH_TABLE(INDEX);
       elsif
         ((TEMP_PTR.NEXT_DICTIONARY /= null) and (COUNT > 0))
         then
           while(TEMP_PTR.NEXT_DICTIONARY /= null) and then
                (not(TEMP_PTR.NEXT_DICTIONARY.ENABLED)) loop
             TEMP_PTR := TEMP_PTR.NEXT_DICTIONARY;
           end loop;
         if TEMP_PTR.NEXT_DICTIONARY = null
         then
           COUNT := 0;
           raise NO_MORE_WORDS;
         else
           TEMP_PTR := TEMP_PTR.NEXT_DICTIONARY;
           WORD_PTR := TEMP_PTR.HASH_TABLE(INDEX);
         end if;
      else

--The exception raised when there are no more words available

        COUNT := 0;
        raise NO_MORE_WORDS;
      end if;
    end loop;
  end NEXT_WORD;

----------------------------------------------------------------
--
-- Abstract     :  This procedure initializes the search for like
--              :  words to be returned to the spelling corrector.
--              :  The variables are global to package DICTIONARY_
--              :  MANAGER and are thus available for the routines
--              :  MORE and NEXT_WORD to use.
--
----------------------------------------------------------------
--
-- Parameters   :  TOKEN     -  An in parameter containing the word
--              :               and its length to be used as a possible match.
--              :  NUMBER    -  The number of possible correct words
--              :               to be returned.
--
----------------------------------------------------------------
--
-- Algorithm    :  Within this procedure certain global variables
--              :  are set to values that are passed from a calling
--              :  routine.  These values are then used to locate
--              :  and return words that may be possible corrections
--              :  for a misspelling.  These values are used by the
--              :  routines NEXT_WORD and MORE.
--
----------------------------------------------------------------

  procedure INITIATOR(TOKEN : in TOKEN_DEFINITION.TOKEN_TYPE;
                      NUMBER : in POSITIVE) is

  begin

--The check for the proper word length

    if TOKEN.LENGTH < NECESSARY_LENGTH
    then
      raise BAD_WORD;
    end if;

--The check for a valid dictionary

    if DICTIONARY_SEARCH_LIST = null
    then
      raise DICTIONARY_ERROR;
    else

--The initialization process starts here

      COUNT := NUMBER;
      INDEX := (HASH_VALUE(TOKEN.WORD(1),TOKEN.WORD(2),TOKEN.LENGTH));
      WORD_PTR := DICTIONARY_SEARCH_LIST.HASH_TABLE(INDEX);
      INIT_WORD := TOKEN;
      TEMP_PTR := DICTIONARY_SEARCH_LIST;
    end if;
  end INITIATOR;

end DICTIONARY_MANAGER;
::::::::::
DH_SPEC.ADA
::::::::::
--
-- DOCUMENT_HANDLER by Richard Conn, TI Ada Technology Branch
-- 27 Feb 85
--
with TEXT_IO,
     MACHINE_DEPENDENCIES,
     TOKEN_DEFINITION;
package DOCUMENT_HANDLER is
--------------------------------------------------------------------------
-- Abstract   : DOCUMENT_HANDLER provides input from a document, which
--               is specified to OPEN_SOURCE by a pathname/filename.
--               It returns a WORD from this document each time the routine
--               GET_WORD is called.  When there are no more WORDs in the
--               document, the exception NO_MORE_WORDS is raised.
--
--              DOCUMENT_HANDLER can also create a second document, the
--               destination, or output, document.  This facility is
--               enabled when the routine OPEN_DESTINATION is called,
--               where the pathname/filename of the new document is the
--               passed parameter.  The destination document is a mirror
--               of the source document, except that selected words can
--               be replaced with other words via the RESTORE_WORD routine.
--               RESTORE_WORD replaces the last word returned by GET_WORD
--               with a new word.
--
--              The context, or lines surrounding the last word returned
--               by GET_WORD, can be obtained from the CONTEXT_OF_LAST_
--               GET_WORD routine.  This routine returns LINES, which is
--               an array of strings, and an INDEX, which is the offset
--               to the first character of the last word returned by
--               GET_WORD, and LENGTH, which is the number of characters
--               in this word.  The constant, TARGET_LINE_IN_CONTEXT,
--               is the index of the line of the context which contains
--               the indicated word.
--
--------------------------------------------------------------------------

    subtype TOKEN is TOKEN_DEFINITION.TOKEN_TYPE;

    MAX_LINE                   : constant POSITIVE :=
                 MACHINE_DEPENDENCIES.FILE_LINE_LENGTH;
    NUMBER_OF_LINES_IN_CONTEXT : constant NATURAL := 3;
    TARGET_LINE_IN_CONTEXT     : constant NATURAL := 2;
    type CONTEXT_ELEMENT is
    record
        LINE : STRING (1 .. MAX_LINE);
        LAST : NATURAL;
    end record;
    type CONTEXT is array (1 .. NUMBER_OF_LINES_IN_CONTEXT) of CONTEXT_ELEMENT;

    -- Note: Exceptions from TEXT_IO may also be raised
    RESTORE_FAILED  : exception;
    NO_MORE_WORDS   : exception;
    SOURCE_NOT_OPEN : exception;

    procedure OPEN_SOURCE (FILE_NAME : STRING);
--------------------------------------------------------------------------
-- Abstract   : The source document from which future words are to be
--               returned is opened for input.  GET_WORD returns these
--               words.
--------------------------------------------------------------------------
-- Parameters : FILE_NAME      - Pathname/Filename of file containing
--                               document
--------------------------------------------------------------------------


    procedure OPEN_DESTINATION (FILE_NAME : STRING);
--------------------------------------------------------------------------
-- Abstract   : The destination document which is built of words from the
--               source document and new, correctly-spelled words provided
--               through RESTORE_WORD
--------------------------------------------------------------------------
-- Parameters : FILE_NAME      - Pathname/Filename of file to contain
--               the destination document
--------------------------------------------------------------------------


    procedure CLOSE_SOURCE_AND_DESTINATION;
--------------------------------------------------------------------------
-- Abstract   : Close both the source document and destination document
--               files
--------------------------------------------------------------------------
-- Parameters : None
--------------------------------------------------------------------------


    procedure GET_WORD (WORD : out TOKEN; WORD_IN_BOUNDS : out BOOLEAN);
--------------------------------------------------------------------------
-- Abstract   : Return the next word from the Source Document
--------------------------------------------------------------------------
-- Parameters : WORD           - the next word from the source document;
--                               this structure includes the word itself
--                               (as a string) and the word length
--              WORD_IN_BOUNDS - TRUE if WORD is small enough to fit in
--                               a TOKEN; FALSE if WORD is larger than
--                               the maximum size of a TOKEN; if FALSE,
--                               the full word can be obtained from
--                               the procedure CONTEXT
--------------------------------------------------------------------------


    procedure RESTORE_WORD (WORD : STRING);
--------------------------------------------------------------------------
-- Abstract   : Replace the last word obtained from GET_WORD with the
--               passed string (WORD); the replacement is done in the
--               destination document only (the source document is not
--               affected)
--------------------------------------------------------------------------
-- Parameters : WORD           - the string containing the new word
--------------------------------------------------------------------------


    procedure CONTEXT_OF_LAST_GET_WORD (LINES  : out CONTEXT;
                    INDEX  : out NATURAL;
                    LENGTH : out NATURAL);
--------------------------------------------------------------------------
-- Abstract   : Return the lines surrounding and including the last word
--               returned by GET_WORD; also return the INDEX and LENGTH
--               of the last word returned by GET_WORD which indicate
--               its position in the TARGET_LINE_IN_CONTEXT
--------------------------------------------------------------------------
-- Parameters : LINES          - the context (lines) surrounding the last
--                               word
--              INDEX          - the offset to the first character of the
--                               last word in TARGET_LINE_IN_CONTEXT
--              LENGTH         - number of characters in the last word
--                               in TARGET_LINE_IN_CONTEXT
--------------------------------------------------------------------------

end DOCUMENT_HANDLER;
::::::::::
DH_BODY.ADA
::::::::::
with CHARACTER_SET;
package body DOCUMENT_HANDLER is

    LAST_TIME       : BOOLEAN := FALSE;
    LINES_REMAINING : NATURAL;
--
    NEXT_CHAR       : NATURAL := 0;
    IS_CHAR_PENDING : BOOLEAN := FALSE;
    PENDING_CHAR    : CHARACTER;
--
    LAST_WORD_INDEX  : NATURAL;
    LAST_WORD_LENGTH : NATURAL;
--
    OUTPUT_FILE : TEXT_IO.FILE_TYPE;
    INPUT_FILE  : TEXT_IO.FILE_TYPE;
--
    CONTEXT_LINE : CONTEXT;

--
-- Set up for input of source file
--
    procedure OPEN_SOURCE (FILE_NAME : STRING) is
    begin
    TEXT_IO.OPEN (INPUT_FILE, TEXT_IO.IN_FILE, FILE_NAME);
    --
    -- Initialize Context Buffer
    --
    for I in CONTEXT_LINE'FIRST .. CONTEXT_LINE'LAST loop
        CONTEXT_LINE (I).LINE (1) := ASCII.NUL;
        CONTEXT_LINE (I).LAST := 0;
    end loop;
    --
    -- Read in first set of context lines from file
    --
    begin
        for I in TARGET_LINE_IN_CONTEXT .. NUMBER_OF_LINES_IN_CONTEXT loop
        TEXT_IO.GET_LINE
           (INPUT_FILE, CONTEXT_LINE (I).LINE (1 .. MAX_LINE - 1),
            CONTEXT_LINE (I).LAST);
        CONTEXT_LINE (I).LAST := CONTEXT_LINE (I).LAST + 1;
        CONTEXT_LINE (I).LINE (CONTEXT_LINE (I).LAST) := ASCII.NUL;
        end loop;
    exception
        when others =>
        null;      -- very short file
    end;
    --
    -- Set index to first char of target_line_in_context
    --
    NEXT_CHAR := 1;

    end OPEN_SOURCE;

--
-- Set up for output of modified input file to a "restored" document
--
    procedure OPEN_DESTINATION (FILE_NAME : STRING) is
    begin
    TEXT_IO.CREATE (OUTPUT_FILE, TEXT_IO.OUT_FILE, FILE_NAME);
    exception
    when others =>
        TEXT_IO.OPEN (OUTPUT_FILE, TEXT_IO.OUT_FILE, FILE_NAME);
    end OPEN_DESTINATION;

--
-- Init all key system variables so DOCUMENT_HANDLER may be invoked several
--  times in one run
--
    procedure RESET_DOCUMENT_HANDLER is
    begin
    LAST_TIME := FALSE;
    IS_CHAR_PENDING := FALSE;
    NEXT_CHAR := 0;
    end RESET_DOCUMENT_HANDLER;

--
-- Close Input and Output Files and Reset the Document Handler
--
    procedure CLOSE_SOURCE_AND_DESTINATION is
    begin
    if TEXT_IO.IS_OPEN (OUTPUT_FILE) then
        TEXT_IO.CLOSE (OUTPUT_FILE);
    end if;
    if TEXT_IO.IS_OPEN (INPUT_FILE) then
        TEXT_IO.CLOSE (INPUT_FILE);
    end if;
    RESET_DOCUMENT_HANDLER;
    end CLOSE_SOURCE_AND_DESTINATION;

--
-- GET_NEW_LINE moves the context lines down one and inputs a new
--      third context line from the input file
--
    procedure GET_NEW_LINE is
    INPUT_LINE        : STRING (1 .. MAX_LINE);
    INPUT_LINE_LENGTH : NATURAL;
    begin
    if not TEXT_IO.IS_OPEN (INPUT_FILE) then
        raise SOURCE_NOT_OPEN;
    end if;
    if TEXT_IO.IS_OPEN (OUTPUT_FILE) then
        TEXT_IO.PUT_LINE (OUTPUT_FILE,
                  CONTEXT_LINE (TARGET_LINE_IN_CONTEXT).LINE
                 (1 .. CONTEXT_LINE (TARGET_LINE_IN_CONTEXT)
                    .LAST - 1));
    end if;
    if not LAST_TIME then
--
-- Move context lines down one line
--
        for I in 2 .. NUMBER_OF_LINES_IN_CONTEXT loop
        CONTEXT_LINE (I - 1) := CONTEXT_LINE (I);
        end loop;
        --
        -- Initialize last line in case GET_LINE fails
        --
        CONTEXT_LINE (NUMBER_OF_LINES_IN_CONTEXT).LINE (1) := ASCII.NUL;
        CONTEXT_LINE (NUMBER_OF_LINES_IN_CONTEXT).LAST := 0;
        --
        -- Get next line from input file
        --
        TEXT_IO.GET_LINE (INPUT_FILE, INPUT_LINE (1 .. MAX_LINE - 1),
                  INPUT_LINE_LENGTH);
        --
        -- Store next line into last line in context
        --
        CONTEXT_LINE (NUMBER_OF_LINES_IN_CONTEXT).LINE := INPUT_LINE;
        CONTEXT_LINE (NUMBER_OF_LINES_IN_CONTEXT).LINE
           (INPUT_LINE_LENGTH + 1) := ASCII.NUL;
        CONTEXT_LINE (NUMBER_OF_LINES_IN_CONTEXT).LAST :=
          INPUT_LINE_LENGTH + 1;
    else
--
-- Move context lines down one line
--
        for I in 2 .. NUMBER_OF_LINES_IN_CONTEXT loop
        CONTEXT_LINE (I - 1) := CONTEXT_LINE (I);
        end loop;
        --
        -- Clear last line in context
        --
        CONTEXT_LINE (NUMBER_OF_LINES_IN_CONTEXT).LINE (1) := ASCII.NUL;
        CONTEXT_LINE (NUMBER_OF_LINES_IN_CONTEXT).LAST := 0;
        LINES_REMAINING := LINES_REMAINING - 1;
        if LINES_REMAINING = 0 then
        raise NO_MORE_WORDS;
        end if;
    end if;
    exception
    when TEXT_IO.END_ERROR =>
        LAST_TIME := TRUE;
        LINES_REMAINING :=
          NUMBER_OF_LINES_IN_CONTEXT - TARGET_LINE_IN_CONTEXT;
    when NO_MORE_WORDS =>
        raise;
    when others =>
        TEXT_IO.PUT_LINE ("Unknown Exception in GET_NEW_LINE");
        raise;
    end GET_NEW_LINE;

--
-- GETC returns the next character from the input stream
--
    procedure GETC (CH : out CHARACTER) is
    begin
    if IS_CHAR_PENDING then
        CH := PENDING_CHAR;
        IS_CHAR_PENDING := FALSE;
    else
        if NEXT_CHAR > CONTEXT_LINE (TARGET_LINE_IN_CONTEXT).LAST then
        NEXT_CHAR := 1;
        loop
            GET_NEW_LINE;
            exit when NEXT_CHAR <=
                  CONTEXT_LINE (TARGET_LINE_IN_CONTEXT).LAST;
        end loop;
        end if;
        CH := CONTEXT_LINE (TARGET_LINE_IN_CONTEXT).LINE (NEXT_CHAR);
        NEXT_CHAR := NEXT_CHAR + 1;
    end if;
    end GETC;

--
-- UNGETC prepends a character back into the front of the input stream
--
    procedure UNGETC (CH : CHARACTER) is
    begin
    IS_CHAR_PENDING := TRUE;
    PENDING_CHAR := CH;
    end UNGETC;

--
-- IS_DIGIT_ELEMENT returns true if the indicated char is a number or
--  one of the special numeric characters
--
    function IS_DIGIT_ELEMENT (CH : CHARACTER) return BOOLEAN is
    begin
    if CHARACTER_SET.IS_DIGIT (CH) or
       TOKEN_DEFINITION.IS_SPECIAL_CHAR (CH) then
        return TRUE;
    else
        return FALSE;
    end if;
    end IS_DIGIT_ELEMENT;

--
-- GET_WORD returns the next word from the input stream
--
    procedure GET_WORD (WORD : out TOKEN; WORD_IN_BOUNDS : out BOOLEAN) is
    LETTER_IN      : CHARACTER;
    WORD_IN        : STRING (1 .. TOKEN_DEFINITION.TOKEN_LENGTH);
    WORD_INDEX     : NATURAL;
    ALPHA_DETECTED : BOOLEAN;
--
-- Determine if the character is a part of a word
--
    function IS_PART_OF_WORD (CH : CHARACTER) return BOOLEAN is
        LETTER_NEXT : CHARACTER;
    begin
        if not (CHARACTER_SET.IS_ALPHA_NUMERIC (CH) or
            TOKEN_DEFINITION.IS_SPECIAL_CHAR (CH)) then
        return FALSE;
        else
        if TOKEN_DEFINITION.IS_SPECIAL_CHAR (CH) then
            GETC (LETTER_NEXT);
            UNGETC (LETTER_NEXT);
            if not CHARACTER_SET.IS_ALPHA_NUMERIC (LETTER_NEXT) then
            return FALSE;
            else
            return TRUE;
            end if;
        else
            return TRUE;
        end if;
        end if;
    end IS_PART_OF_WORD;

--
-- Mainline of GET_WORD
--
    begin
    if not TEXT_IO.IS_OPEN (INPUT_FILE) then
        raise SOURCE_NOT_OPEN;
    end if;
--
-- Major loop in case an all-numeric/special-numeric word is built
--
    loop
--
-- Look for the start of the next word
--
        loop
        GETC (LETTER_IN);
        exit when CHARACTER_SET.IS_ALPHA_NUMERIC (LETTER_IN);
        end loop;
        --
        -- Set LAST_WORD_INDEX to point to first char of current word
        --
        if NEXT_CHAR = 1 then
        LAST_WORD_INDEX := NEXT_CHAR;
        else
        LAST_WORD_INDEX := NEXT_CHAR - 1;
        end if;
        --
        -- Build current word
        --
        ALPHA_DETECTED := CHARACTER_SET.IS_ALPHA (LETTER_IN);
        WORD_IN (1) := LETTER_IN;
        WORD_INDEX := 1;
        loop
        GETC (LETTER_IN);
        exit when not IS_PART_OF_WORD (LETTER_IN);
        if WORD_INDEX = WORD_IN'LAST then
            loop
            WORD_INDEX := WORD_INDEX + 1;
            GETC (LETTER_IN);
            if CHARACTER_SET.IS_ALPHA (LETTER_IN) then
                ALPHA_DETECTED := TRUE;
            end if;
            exit when not IS_PART_OF_WORD (LETTER_IN);
            end loop;
            exit;
        else
            WORD_INDEX := WORD_INDEX + 1;
            WORD_IN (WORD_INDEX) := LETTER_IN;
            if CHARACTER_SET.IS_ALPHA (LETTER_IN) then
            ALPHA_DETECTED := TRUE;
            end if;
        end if;
        end loop;
        if (WORD_INDEX /= WORD_IN'LAST) and
           (TOKEN_DEFINITION.IS_SPECIAL_CHAR (LETTER_IN)) and
           (LETTER_IN /= '-') then
        WORD_INDEX := WORD_INDEX + 1;
        WORD_IN (WORD_INDEX) := LETTER_IN;
        end if;
        --
        -- Exit major loop if the word contains at least one alphabetic
        --
        exit when ALPHA_DETECTED;
    end loop;
    --
    -- Set length of LAST_WORD in case RESTORE_WORD is called
    --
    LAST_WORD_LENGTH := WORD_INDEX;
    --
    -- Set returned values
    --
    WORD.WORD := WORD_IN;
    if WORD_INDEX <= WORD_IN'LAST then
        WORD.LENGTH := WORD_INDEX;
        WORD_IN_BOUNDS := TRUE;
    else
        WORD.LENGTH := WORD_IN'LAST;
        WORD_IN_BOUNDS := FALSE;
    end if;

    end GET_WORD;


--
-- RESTORE_WORD replaces the word indexed by LAST_WORD_INDEX with the
--  passed word
--
    procedure RESTORE_WORD (WORD : STRING) is
    LENGTH_OF_PREFIX        : NATURAL;
    LENGTH_OF_POSTFIX       : NATURAL;
    LENGTH_OF_RESTORED_LINE : NATURAL;
    begin
--
-- Check to see that at least the input file is open
--
    if not TEXT_IO.IS_OPEN (INPUT_FILE) then
        raise SOURCE_NOT_OPEN;
    end if;
    --
    -- Compute number of characters in prefix (before old word) and postfix
    --  (after old word)
    --  Compute length of line after new word is inserted into it
    --  Compute location of NEXT_CHAR pointer (after new word)
    --
    LENGTH_OF_PREFIX := LAST_WORD_INDEX - 1;
    LENGTH_OF_POSTFIX := CONTEXT_LINE (TARGET_LINE_IN_CONTEXT).LAST -
                 (LAST_WORD_INDEX + LAST_WORD_LENGTH - 1);
    LENGTH_OF_RESTORED_LINE :=
      CONTEXT_LINE (TARGET_LINE_IN_CONTEXT).LAST + WORD'LENGTH -
      LAST_WORD_LENGTH;
    NEXT_CHAR := LAST_WORD_INDEX + WORD'LENGTH;
    --
    -- Check to see if the restore will fail
    --
    if LENGTH_OF_RESTORED_LINE > MAX_LINE - 1 then
        raise RESTORE_FAILED;
    else
        --
        -- Copy current line up to old word, copy in new word,
        --  and then copy in rest of current line after old word
        --
        CONTEXT_LINE (TARGET_LINE_IN_CONTEXT).LINE
           (1 .. LENGTH_OF_RESTORED_LINE) :=
          CONTEXT_LINE (TARGET_LINE_IN_CONTEXT).LINE
         (1 .. LENGTH_OF_PREFIX) & WORD &
          CONTEXT_LINE (TARGET_LINE_IN_CONTEXT).LINE
         (LAST_WORD_INDEX + LAST_WORD_LENGTH ..
          CONTEXT_LINE (TARGET_LINE_IN_CONTEXT).LAST);
        --
        -- Replace current line length
        --
        CONTEXT_LINE (TARGET_LINE_IN_CONTEXT).LAST :=
          LENGTH_OF_RESTORED_LINE;
    end if;

    LAST_WORD_LENGTH := WORD'LENGTH;

    end RESTORE_WORD;

--
-- CONTEXT_OF_LAST_GET_WORD returns the context lines
--
    procedure CONTEXT_OF_LAST_GET_WORD (LINES  : out CONTEXT;
                    INDEX  : out NATURAL;
                    LENGTH : out NATURAL) is
    begin
    if not TEXT_IO.IS_OPEN (INPUT_FILE) then
        raise SOURCE_NOT_OPEN;
    end if;
    LINES := CONTEXT_LINE;
    INDEX := LAST_WORD_INDEX;
    LENGTH := LAST_WORD_LENGTH;
    end CONTEXT_OF_LAST_GET_WORD;

begin
    RESET_DOCUMENT_HANDLER;
end DOCUMENT_HANDLER;
::::::::::
RTS.ADA
::::::::::
--
-- RUN_TIME_STATISTICS by Richard Conn, TI Ada Technology Branch
-- 27 Feb 85
--

with COUNT_STATISTICS;
package RUN_TIME_STATISTICS is
--------------------------------------------------------------------------
-- Abstract   : run_time_STATISTICS maintains counters which may be used
--               to keep track of the frequency of certain error
--               conditions, as enumerated in the type STATISTIC.  To
--               use this package, the routine INITIALIZE_COUNTERS will
--               clear all counters, the routine INCREMENT_COUNTER will
--               increment the indicated counter, and the routine
--               COUNT will return the value of the indicated counter.
--
--------------------------------------------------------------------------

    type STATISTIC is
     (CORRECTED_WORDS,       SUSPECT_WORDS,         FAILED_RESTORES,
      WORDS_CHANGING_LENGTH);

    package RTS is new COUNT_STATISTICS (STATISTIC);

    procedure INITIALIZE_COUNTERS renames RTS.INITIALIZE_COUNTERS;
--------------------------------------------------------------------------
-- Abstract   : This routine sets the values of all counters to zero.
--------------------------------------------------------------------------


    procedure INCREMENT_COUNTER (COUNTER : STATISTIC)
                  renames RTS.INCREMENT_COUNTER;
--------------------------------------------------------------------------
-- Abstract   : This routine increments the indicated counter.
--------------------------------------------------------------------------


    function COUNT (COUNTER : STATISTIC) return NATURAL renames RTS.COUNT;
--------------------------------------------------------------------------
-- Abstract   : This routine returns the value of the indicated counter.
--------------------------------------------------------------------------

end RUN_TIME_STATISTICS;
::::::::::
WORD_LIST_SPEC.ADA
::::::::::
with Text_IO,
     Token_Definition;
package Misspelled_Word_List is
--------------------------------------------------------------------------
-- Abstract   : This package maintains a list of tokens with a frequency
--              count and prints the list in ascending order on request.
--------------------------------------------------------------------------

  procedure Initialize;
--------------------------------------------------------------------------
-- Abstract   : This procedure empties the misspelled word list.
--------------------------------------------------------------------------

  procedure Add_Token (Token : Token_Definition.Token_Type);
--------------------------------------------------------------------------
-- Abstract   : This procedure inserts a token into the linked list in
--              ascending order (or if already in the list, increments
--              its count).
--------------------------------------------------------------------------
-- Parameters : Token - is the token to be inserted into the list.
--------------------------------------------------------------------------

  procedure Print (File : Text_IO.File_Type);
--------------------------------------------------------------------------
-- Abstract   : Print the list (token and count) from head to tail, one
--              element per line.  The count is printed in columns beyond
--              the maximum length of a token so that the file may be used
--              as a dictionary.
--------------------------------------------------------------------------
-- Parameters : File - is the file to which the list is to be written.
--------------------------------------------------------------------------

end Misspelled_Word_List;
::::::::::
WORD_LIST_BODY.ADA
::::::::::
with Equality_Operator,
     Singly_Linked_List;
package body Misspelled_Word_List is
--------------------------------------------------------------------------
-- Abstract   : This package maintains a list of tokens with a frequency
--              count and prints the list in ascending order on request.
--------------------------------------------------------------------------

  type Token_Counter is
    record
      Token : Token_Definition.Token_Type;
      Count : Positive;
    end record;

  package Singly_Linked_Word_List is new Singly_Linked_List (Token_Counter);
  use Singly_Linked_Word_List;

  procedure Increment (Element : in out Token_Counter);

  procedure Increment_Counter is new Singly_Linked_Word_List.Modify (Increment);

  Token_Counter_List : Singly_Linked_Word_List.List_Type;

  procedure Increment (Element : in out Token_Counter) is
--------------------------------------------------------------------------
-- Abstract   : Increment the count field of an element
--------------------------------------------------------------------------
-- Parameters : Element - is the element to have its count field incremented
--------------------------------------------------------------------------
  begin
    Element.Count := Element.Count + 1;
  end Increment;

  procedure Initialize is
--------------------------------------------------------------------------
-- Abstract   : This procedure empties the misspelled word list.
--------------------------------------------------------------------------
-- Algorithm  : Go to the head of the list and delete the head element
--              until the list is empty.
--------------------------------------------------------------------------
  begin
    First (Token_Counter_List);
    while not Empty (Token_Counter_List) loop
      Delete_Element (Token_Counter_List);
    end loop;
  end Initialize;

  procedure Add_Token (Token : Token_Definition.Token_Type) is
--------------------------------------------------------------------------
-- Abstract   : This procedure inserts a token into the linked list in
--              ascending order (or if already in the list, increments
--              its count).
--------------------------------------------------------------------------
-- Parameters : Token - is the token to be inserted into the list.
--------------------------------------------------------------------------
-- Algorithm  : (a) Go to the head of the list.
--              (b) Traverse the list until the end of the list is
--                  encountered or a token is found in the list that has
--                  a value greater than or equal to the input parameter.
--              (c) select
--                    end-of-list =>
--                      insert input parameter at end of list
--                    input parameter found in list =>
--                      increment counter
--                    token in list is greater than input parameter =>
--                      insert the input parameter in front of the element
--------------------------------------------------------------------------
    function Equals (Left, Right : Token_Definition.Token_Type) return Boolean;

    package Token_Equality is new Equality_Operator
         (Token_Definition.Token_Type, Equals);
    function "=" (Left, Right : Token_Definition.Token_Type) return Boolean
                   renames Token_Equality.Equals."=";

    function Equals (Left, Right : Token_Definition.Token_Type)
                      return Boolean is
--------------------------------------------------------------------------
-- Abstract   : This function defines equality for tokens.
--------------------------------------------------------------------------
-- Parameters : Left & Right -- are tokens to be compared for equality.
--------------------------------------------------------------------------
    begin
      return Left.Word (Left.Word'First .. Left.Length) =
             Right.Word (Right.Word'First .. Right.Length);
    end Equals;

    function ">" (Left, Right : Token_Definition.Token_Type) return Boolean is
--------------------------------------------------------------------------
-- Abstract   : This function defines the "greater than" relation for tokens.
--------------------------------------------------------------------------
-- Parameters : Left & Right -- are tokens to be compared
--------------------------------------------------------------------------
    begin
      return Left.Word (Left.Word'First .. Left.Length) >
             Right.Word (Right.Word'First .. Right.Length);
    end ">";

  begin
    First (Token_Counter_List);

    while (not Null_Node (Token_Counter_List)) and then
          (Token > Current_Element (Token_Counter_List).Token) loop
      Next (Token_Counter_List);
    end loop;

    if Null_Node (Token_Counter_List) then
      Insert_After (List    => Token_Counter_List,
                    Element => Token_Counter'(Token, 1));
    elsif Token = Current_Element (Token_Counter_List).Token then
      Increment_Counter (Token_Counter_List);
    else
      Insert_Before (List    => Token_Counter_List,
                     Element => Token_Counter'(Token, 1));
    end if;
  end Add_Token;

  procedure Print (File : Text_IO.File_Type) is
--------------------------------------------------------------------------
-- Abstract   : Print the list (token and count) from head to tail, one
--              element per line.  The count is printed in columns beyond
--              the maximum length of a token so that the file may be used
--              as a dictionary.
--------------------------------------------------------------------------
-- Parameters : File - is the file to which the list is to be written.
--------------------------------------------------------------------------

    package Integer_IO is new Text_IO.Integer_IO (Positive);

    function "+" (L, R : Text_IO.Count) return Text_IO.Count
             renames Text_IO."+";

    Max_Token_Width     : constant Natural := Token_Definition.Token_Length;
    Counter_Width       : constant := 5;

  begin
    First (Token_Counter_List);

    while not Null_Node (Token_Counter_List) loop
        Text_IO.Put (File,
                     Current_Element (Token_Counter_List).Token.Word
                        (1 .. Current_Element (Token_Counter_List).Token
                               .Length));

        Next (Token_Counter_List);
      Text_IO.New_Line (File);
    end loop;

  end Print;

begin
  Initialize;
end Misspelled_Word_List;
::::::::::
HELPINFO_SPEC.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    : HELP_INFO_SUPPORT
-- Date created : 9-10-84
-- Last update  : 02-07-85  Tom Duke  -  deleted HELP_INFO_COMMAND_ENUM,
----------------: STACK_FRAME, STATE_INFO_RECORD, and STATE_INFO_POINTER
----------------: types.  Deleted procedure CLEAR_TEXT_ARRAY.
----------------: 12-18-84  Tom Duke  -  added IDENTIFY_KEYWORD,
----------------: GET_NEXT_TOKEN, and PARSE procedures.  Added types,
----------------: subtypes, and variables used in these procdures.
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     : The HELP_INFO_SUPPORT package provides the constants
----------------: and types to support the implementation of the AIM
----------------: Help and Info utilities.
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------


package HELP_INFO_SUPPORT is


MAX_LINE_LENGTH              :  constant INTEGER := 80;
MAX_LEVEL                    :  constant INTEGER := 10;

TOKEN_SEPARATER              :  constant CHARACTER := ' ';


-- types and pointers for APPEND_TO_DISPLAY ------------

subtype FILE_TEXT_LINE is string(1..MAX_LINE_LENGTH);

type TEXT_LINE;
type TEXT_LINK  is access TEXT_LINE;
type TEXT_LINE is
     record
            TEXT_LINE        : FILE_TEXT_LINE;
            LINE_LENGTH      : natural := 0;
            NEXT_LINE        : TEXT_LINK := null;
    end record;

TOP_LINE: TEXT_LINK := new TEXT_LINE;
CURRENT_LINE: TEXT_LINK := TOP_LINE;
PREVIOUS_LINE: TEXT_LINK := TOP_LINE;
IS_FIRST_TIME: boolean := true;

-----------------------------------------------------------

subtype LEVEL_RANGE is NATURAL range 0..MAX_LEVEL;

subtype HELP_INFO_TEXT_LINE is STRING(1..MAX_LINE_LENGTH);

----------
--  type declarations for the parsed input buffer
----------

subtype LINE_LENGTH is NATURAL range 0..MAX_LINE_LENGTH;
subtype LINE_INDEX is POSITIVE range 1..MAX_LINE_LENGTH;
type TOKEN_RECORD is
   record
      TOKEN      : HELP_INFO_TEXT_LINE;
      LENGTH     : LINE_LENGTH;
      BUFFER_POS : POSITIVE;    -- 1..aim_support.max_data_length
   end record;
subtype NUMBER_OF_TOKENS_RANGE is NATURAL
                      range 0..MAX_LEVEL;
subtype TOKEN_ARRAY_RANGE is POSITIVE
                      range 1..MAX_LEVEL;
type TOKEN_ARRAY is array( TOKEN_ARRAY_RANGE ) of TOKEN_RECORD;

----------
--  Subtype and type which define the structure of the table used
--  for implicit conversion of characters from lowercase to uppercase.
----------
subtype LOWER_CASE_RANGE is CHARACTER range ASCII.LC_A .. ASCII.LC_Z;
type CASE_CONVERSION_TABLE is array( LOWER_CASE_RANGE ) of CHARACTER;

----------
--  Variables used when working with the INPUT_TOKEN_TABLE.
----------
TOKEN_LENGTH    : LINE_LENGTH;
TOKEN_STRING    : HELP_INFO_TEXT_LINE;
TOKEN_POS       : POSITIVE;

----------
--  Pointer to the next character position of the user input string
--  to be accessed during the procedures PARSE and GET_NEXT_INFO_TOKEN.
----------
INPUT_STRING_POS  : POSITIVE;

----------
--  Table used to store individual tokens, their length, and their
--  position in the user's input string.
----------
INPUT_TOKEN_TABLE : TOKEN_ARRAY;

----------
--  Counter for saving the number of tokens extracted from the user's
--  input string.
----------
NUMBER_OF_TOKENS  : NUMBER_OF_TOKENS_RANGE;

----------
--  As the variable type indicates, the case conversion table used
--  for implicit conversion from lowercase to uppercase.
----------
UPPER_CASE : CASE_CONVERSION_TABLE := "ABCDEFGHIJKLMNOPQRSTUVWXYZ";


KEYWORD_NOT_FOUND : exception;

-----------------------------------------------------------

procedure APPEND_TO_DISPLAY(LINE       : in STRING;
                            CHAR_COUNT: in natural);


procedure IDENTIFY_KEYWORD(
          TOKEN_STRING : in HELP_INFO_TEXT_LINE;
          TOKEN_LENGTH : in LINE_LENGTH;
          KEYWORD      : in HELP_INFO_TEXT_LINE );


procedure GET_NEXT_TOKEN(
            INPUT_STRING : in  STRING;
            NEXT_STRING  : out HELP_INFO_TEXT_LINE;
            NEXT_LENGTH  : out LINE_LENGTH;
            NEXT_POS     : out POSITIVE );


procedure PARSE(INPUT_STRING : in STRING);


end HELP_INFO_SUPPORT;
::::::::::
HELPINFO_BODY.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    : HELP_INFO_SUPPORT body
-- Date created : 9-10-84
-- Last update  : 02-07-85  Tom Duke  -  deleted CLEAR_TEXT_ARRAY
----------------: procedure.  Modified GET_NEXT_TOKEN procedure to
----------------: allow all ascii codes <= TOKEN_SEPARATER as valid
----------------: token separaters.  Eliminated special case test for
----------------: ellipsis from procedure IDENTIFY_KEYWORD.
----------------: 01-07-85  Tom Duke  -  added logic to not allow
----------------: abbreviations of ellipsis symbol in IDENTIFY_KEYWORD.
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     : The HELP_INFO_SUPPORT package provides the constants
----------------: and types to support the implementation of the AIM
----------------: Help and Info utilities.
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------


with TEXT_IO;

package body HELP_INFO_SUPPORT is


procedure APPEND_TO_DISPLAY(LINE       : in STRING;
                            CHAR_COUNT: in natural) is

begin

  if LINE'length <= FILE_TEXT_LINE'length then
    CURRENT_LINE.TEXT_LINE := FILE_TEXT_LINE'(others => ' ');
    CURRENT_LINE.TEXT_LINE(1..LINE'length) := LINE;
    CURRENT_LINE.LINE_LENGTH := CHAR_COUNT;
  else
    CURRENT_LINE.TEXT_LINE := LINE(1..FILE_TEXT_LINE'length);
    CURRENT_LINE.LINE_LENGTH := FILE_TEXT_LINE'length;
  end if;

  PREVIOUS_LINE.NEXT_LINE := CURRENT_LINE;
  CURRENT_LINE.NEXT_LINE := null;
  PREVIOUS_LINE := CURRENT_LINE;
  CURRENT_LINE := new TEXT_LINE;

exception
   when others =>
      raise;
end APPEND_TO_DISPLAY;


----------
--  The procedure IDENTIFY_KEYWORD compares the parameter TOKEN_STRING
--                                 to the parameter KEYWORD in an
--  attempt to identify a match.  The global array UPPER_CASE is used
--  to convert the input character to upper case for comparison purposes.
--  Note that the input token string actually remains unchanged.
--     The logic assumes that if the character position pointer TEST_POS
--  is incremented past the value of the parameter TOKEN_LENGTH (the
--  actual length of the input token string) then the TOKEN_STRING must
--  be valid.  This logic allows for abbreviations as small as one character
--  to be identified.
--     If a character mismatch or the CONSTRAINT_ERROR exception is raised,
--  the exception KEYWORD_NOT_FOUND is raised.
----------
procedure IDENTIFY_KEYWORD(
          TOKEN_STRING : in HELP_INFO_TEXT_LINE;
          TOKEN_LENGTH : in LINE_LENGTH;
          KEYWORD      : in HELP_INFO_TEXT_LINE ) is

TEST_POS : POSITIVE;             --  character test position
DONE     : BOOLEAN;

begin
   TEST_POS := 1;
   DONE := FALSE;
   while TEST_POS <= TOKEN_LENGTH and then not DONE loop
      case TOKEN_STRING(TEST_POS) is
         when LOWER_CASE_RANGE =>
            if UPPER_CASE(TOKEN_STRING(TEST_POS)) = KEYWORD(TEST_POS) then
               TEST_POS := TEST_POS + 1;
            else
               DONE := TRUE;
            end if;
         when others =>
            if TOKEN_STRING(TEST_POS) = KEYWORD(TEST_POS) then
               TEST_POS := TEST_POS + 1;
            else
               DONE := TRUE;
            end if;
      end case;
   end loop;
   if TEST_POS <= TOKEN_LENGTH then
      raise KEYWORD_NOT_FOUND;
   end if;

exception
   when CONSTRAINT_ERROR =>
      raise KEYWORD_NOT_FOUND;
   when KEYWORD_NOT_FOUND =>
      raise;
   when others =>
      raise;

end IDENTIFY_KEYWORD;


----------
--  The procedure GET_NEXT_TOKEN extracts, from INPUT_STRING, the
--                                    next character(s) bounded by a
--  valid token separater and another valid token separater or the end
--  of the string.  This procedure assumes that INPUT_STRING_POS is
--  currently positioned between tokens (pointing at a separater
--  character) or is positioned at the first character of some token in
--  the INPUT_STRING.
--     The exception CONSTRAINT_ERROR will be raised when the global
--  variable INPUT_STRING_POS (of type POSITIVE)
--  is greater than the length of INPUT_STRING.  Therefore, this
--  exception is not propagated upward but, is handled to identify the
--  last token in the INPUT_STRING and its length.
--     The expected format of INPUT_STRING is:
--
--                  [^^^]AAA[^^^AAA...][^^^][<CR>]
--
--  where
--          ^^^   represents any number of separaters (spaces or less),
--
--          AAA   represents any number of characters greater than spaces,
--
--          ...   indicates the preceeding pattern may be repeated,
--
--          [ ]   indicates an optional entry in the string,
--
--          <CR>  represents the string delimiter,
--                normally ASCII.CR or ASCII.LF.
--
----------
procedure GET_NEXT_TOKEN(
            INPUT_STRING : in  STRING;
            NEXT_STRING  : out HELP_INFO_TEXT_LINE;
            NEXT_LENGTH  : out LINE_LENGTH;
            NEXT_POS     : out POSITIVE ) is

TEST_POS    : LINE_INDEX;     -- character test position
TEMP_STRING : HELP_INFO_TEXT_LINE := (others => ' ');

begin

   TEST_POS := 1;
----------
--  Find first non-separater character.  Will raise CONSTRAINT_ERROR
--  if INPUT_STRING has trailing spaces with no delimiter.  The
--  exception block correctly handles this situation.
----------
   NEXT_POS := INPUT_STRING_POS;
   while INPUT_STRING(INPUT_STRING_POS) <= TOKEN_SEPARATER loop
      INPUT_STRING_POS := INPUT_STRING_POS + 1;
   end loop;
   NEXT_POS := INPUT_STRING_POS;

----------
--  Extract next token string from input buffer.  A string delimiter,
--  normally ASCII.CR or ASCII.LF, is expected after the last token.
--  If no delimiter exists, a CONSTRINT_ERROR will be raised at the
--  end of the last token in the string.  The exception block correctly
--  handles this situation.
----------
   while INPUT_STRING(INPUT_STRING_POS) > TOKEN_SEPARATER loop
      TEMP_STRING(TEST_POS) := INPUT_STRING(INPUT_STRING_POS);
      TEST_POS := TEST_POS + 1;
      INPUT_STRING_POS := INPUT_STRING_POS + 1;
   end loop;
   NEXT_LENGTH := TEST_POS - 1;
   NEXT_STRING := TEMP_STRING;

exception
   when CONSTRAINT_ERROR =>
      NEXT_LENGTH := TEST_POS - 1;
      NEXT_STRING := TEMP_STRING;
   when others =>
      raise;

end GET_NEXT_TOKEN;


----------
--  The procedure PARSE calls the procedure GET_NEXT_TOKEN to extract
--                      individual tokens from the parameter INPUT_STRING
--  and places these tokens in the INPUT_TOKEN_TABLE along with their
--  length and position within the INPUT_STRING.
--     The exception CONSTRAINT_ERROR is trapped to prevent a premature
--  exit from the info utility.  This exception will occur if the user
--  entered more than the allowable number of tokens, as defined by the
--  subtype TOKEN_ARRAY_RANGE.
--     It is expected that INPUT_STRING will not contain characters with
--  an ascii code less than TOKEN_SEPARATER (space character) except for
--  ASCII.HT (between tokens only) and ASCII.CR or ASCII.LF (possible
--  string delimiters).  If any other character less than TOKEN_SEPARATER
--  is encountered, the character is treated as a string delimiter.
----------
procedure PARSE(INPUT_STRING : in STRING) is

begin
   NUMBER_OF_TOKENS := 0;
   INPUT_STRING_POS := 1;
   TOKEN_LENGTH := 1;
   while INPUT_STRING_POS <= INPUT_STRING'LENGTH
         and then TOKEN_LENGTH > 0 loop
      GET_NEXT_TOKEN(INPUT_STRING,
                     TOKEN_STRING,
                     TOKEN_LENGTH,
                     TOKEN_POS);
      if TOKEN_LENGTH > 0 then
         NUMBER_OF_TOKENS := NUMBER_OF_TOKENS + 1;
         INPUT_TOKEN_TABLE(NUMBER_OF_TOKENS).TOKEN := TOKEN_STRING;
         INPUT_TOKEN_TABLE(NUMBER_OF_TOKENS).LENGTH := TOKEN_LENGTH;
         INPUT_TOKEN_TABLE(NUMBER_OF_TOKENS).BUFFER_POS := TOKEN_POS;
      end if;
   end loop;
exception
   when CONSTRAINT_ERROR =>
      --  occurs when NUMBER_OF_TOKENS > MAX_LEVEL
      null;
   when others =>
      raise;
end PARSE;

end HELP_INFO_SUPPORT;
::::::::::
HELP_SPEC.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    :  HELP_UTILITY                         spec
-- Date created :  28 January 1985
-- Last update  :
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     : VAX like HELP Utility. There are three procedures:
----------------: 1) Initialize - reads the help file into a data structure
----------------: 2) Help_Me - the help driver
----------------: 3) Terminate_help - terminates the help utility
----------------:
----------------: A function is provided to check if help is active
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------

package HELP_UTILITY is

    ILLEGAL_FORMAT_FOR_HELP_FILE: exception;
    HELP_FILE_DOES_NOT_EXIST:     exception;
    CANNOT_OPEN_HELP_FILE:        exception;
    HELP_FILE_NOT_INITIALIZED:    exception;
    NOTHING_TO_OUTPUT:            exception;

    procedure INITIALIZE(HELP_FILE_NAME: in string);

    procedure HELP_ME(CLI_BUFFER: in string);

    procedure GET_TEXT_LINE(LINE: out string;
                            CHAR_COUNT: out natural;
                            IS_LAST: out boolean);

    procedure EXIT_HELP;

    procedure RESET_HELP;

    function HELP_IS_TERMINATED return boolean;

end HELP_UTILITY;
::::::::::
HELP_BODY.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    :  HELP_UTILITY         body
-- Date created :  28 January 1985
-- Last update  :
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     : Body for the HELP Utility
----------------: Contains the data strucutures and procedures used in the
----------------: help utility other than those in the support package.
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------

with TEXT_IO;
with HELP_INFO_SUPPORT;
use HELP_INFO_SUPPORT;

package body HELP_UTILITY is

-- Text File for Help Utility

    HELP_FILE_TYPE: text_io.file_type;

-- Tree Data Structures

    type HELP_TOPIC;
    type HELP_LINK  is access HELP_TOPIC;
    type HELP_TOPIC is
        record
            NAME             : FILE_TEXT_LINE;
            NAME_LENGTH      : positive := 1;
            LEVEL            : natural := 1;
            TEXT_LINES       : HELP_INFO_SUPPORT.TEXT_LINK := null;
            SUBTOPICS        : HELP_LINK := null; -- link to first subtopic
            PARENT           : HELP_LINK := null; -- link to parent record
            NEXT_TOPIC       : HELP_LINK := null; -- link to next on same level
        end record;

-- other common needs

    TOP_NODE     : HELP_LINK := new HELP_TOPIC;
    CURRENT_NODE: HELP_LINK := null;

    OUTPUT_LINE: HELP_INFO_SUPPORT.HELP_INFO_TEXT_LINE;
    BLANK_LINE : HELP_INFO_TEXT_LINE :=
                         (1..HELP_INFO_SUPPORT.MAX_LINE_LENGTH =>' ');
    HEADER_LINE: constant string := "Information Available:";
    ADD_HEADER_LINE: constant string := "Additional Information Available:";
    TERM_LINE: constant string := "Help Terminated";
    TOPIC_LINE: constant string := "topic? ";
    SUBTOPIC_LINE: constant string := "subtopic? ";
    NO_DOC_LINE: constant string := "Sorry, no documentation available on ";

    HELP_MODE: boolean := false;
    FIRST_HELP_ME_CALL: boolean := true;
    INITIALIZED: boolean := false;

-- Procedures

    procedure INITIALIZE(HELP_FILE_NAME: in string)
           is separate;

    procedure FIND_KEYWORD(NODE_NAME: in string;
                           NODE_NAME_LENGTH: in natural;
                           NODE: in HELP_LINK;
                           KEYWORD_MATCHES: out HELP_LINK;
                           MATCH_COUNT: in out natural)
           is separate;

    procedure PRINT_TOPIC_MENU(NODE: in HELP_LINK)
           is separate;

    procedure PRINT_TOPIC_TEXT(NODE: in HELP_LINK)
           is separate;

    procedure PRINT_CURRENT_PROMPT(NODE: in HELP_LINK)
           is separate;

    procedure DISPLAY_ALL_HELP_INFO(NODE: in HELP_LINK)
           is separate;

    procedure HELP_ME(CLI_BUFFER: in string)
           is separate;

    procedure GET_TEXT_LINE(LINE: out string;
                            CHAR_COUNT: out natural;
                            IS_LAST: out boolean)
           is separate;

    procedure EXIT_HELP
           is separate;

    procedure RESET_HELP
           is separate;

    function HELP_IS_TERMINATED return boolean is
    begin
      if HELP_MODE then
        return false;
      else
        return true;
      end if;
    end HELP_IS_TERMINATED;

end HELP_UTILITY;
::::::::::
HELP_DIS_ALL.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    :  DISPLAY_ALL_HELP_INFO
-- Date created :  28 January 1985
-- Last update  :
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     :  This procedure prints all information under the
----------------: given node including text and menu.
----------------: It traverses the tree using recursion.
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------


separate(HELP_UTILITY)
procedure DISPLAY_ALL_HELP_INFO(NODE: in HELP_UTILITY.HELP_LINK) is

BLANK_LINE_LENGTH: constant positive := 1;

begin

HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                                    BLANK_LINE_LENGTH);
HELP_UTILITY.OUTPUT_LINE := HELP_UTILITY.BLANK_LINE;
HELP_UTILITY.OUTPUT_LINE(1..NODE.NAME_LENGTH) := NODE.NAME(1..NODE.NAME_LENGTH);
HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.OUTPUT_LINE,
                                    NODE.NAME_LENGTH);
HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                                    BLANK_LINE_LENGTH);
HELP_UTILITY.PRINT_TOPIC_TEXT(NODE);

if NODE.SUBTOPICS /= null then
  HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                                    BLANK_LINE_LENGTH);
  HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.ADD_HEADER_LINE,
                                    HELP_UTILITY.ADD_HEADER_LINE'length);
  HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                                    BLANK_LINE_LENGTH);
  HELP_UTILITY.PRINT_TOPIC_MENU(NODE);
end if;

-- go down subtopics link first

if NODE.SUBTOPICS /= null then
  DISPLAY_ALL_HELP_INFO(NODE.SUBTOPICS);
end if;

-- go down next topic link last

if NODE.NEXT_TOPIC /= null then
  DISPLAY_ALL_HELP_INFO(NODE.NEXT_TOPIC);
end if;

end DISPLAY_ALL_HELP_INFO;
::::::::::
HELP_EXIT.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    :  EXIT_HELP
-- Author       :  BASKETTE
-- Date created :  28 January 1985
-- Last update  :
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     :  The procedure sets the help mode flag to false and
----------------: resets the current node pointer to the top node of the
----------------: tree.
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------


with CURRENT_EXCEPTION;
separate (HELP_UTILITY)
procedure EXIT_HELP is

begin

HELP_UTILITY.CURRENT_NODE := HELP_UTILITY.TOP_NODE;

-- reset HELP_MODE to off

HELP_UTILITY.HELP_MODE := false;
HELP_UTILITY.FIRST_HELP_ME_CALL := TRUE;

end EXIT_HELP;
::::::::::
HELP_FIND.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    :  FIND_KEYWORD
-- Date created :  28 January 1985
-- Last update  :
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     : This procedure will return a node (list of nodes) that
----------------: potentially matches the given name. A count is returned
----------------: of the number of matches.
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------


separate (HELP_UTILITY)
procedure FIND_KEYWORD (NODE_NAME: in string;
                        NODE_NAME_LENGTH: in natural;
                        NODE: in HELP_UTILITY.HELP_LINK;
                        KEYWORD_MATCHES: out HELP_UTILITY.HELP_LINK;
                        MATCH_COUNT: in out natural) is

KEYWORD_NODE: HELP_UTILITY.HELP_LINK := null;
PREV_NODE: HELP_UTILITY.HELP_LINK := null;
CURR_NODE: HELP_UTILITY.HELP_LINK := null;
TOP: HELP_UTILITY.HELP_LINK := CURR_NODE;

begin

KEYWORD_NODE := NODE.SUBTOPICS;
MATCH_COUNT := 0;

-- loop through all subtopics of current level and save any potential matches

while KEYWORD_NODE /= null loop
 begin

-- make the procedure call with input and subtopic name

  HELP_INFO_SUPPORT.IDENTIFY_KEYWORD(
              NODE_NAME,
              NODE_NAME_LENGTH,
              KEYWORD_NODE.NAME);

-- if a match is found, control returns to here, else exception is raised
-- save the match (could be partial match)

  CURR_NODE := new HELP_UTILITY.HELP_TOPIC;
  CURR_NODE.all := KEYWORD_NODE.all;

  if PREV_NODE = null then
    TOP := CURR_NODE;
  else
    PREV_NODE.NEXT_TOPIC := CURR_NODE;
  end if;

  PREV_NODE := CURR_NODE;
  MATCH_COUNT := MATCH_COUNT + 1;

-- if a match is not made then exception is raised

  exception
    when KEYWORD_NOT_FOUND => null;
 end;

 KEYWORD_NODE := KEYWORD_NODE.NEXT_TOPIC;
end loop;

KEYWORD_MATCHES := TOP;

-- other exceptions handled here

  exception
    when others => raise;
end FIND_KEYWORD;
::::::::::
HELP_GET.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    :  GET_TEXT_LINE
-- Date created :  20 Febrauary 1985
-- Last update  :
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     : This procedure allows the user of the HELP_UTILITY
--              : to print the data accumulated by HELP_ME;
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------


separate (HELP_UTILITY)
procedure GET_TEXT_LINE (LINE: out string;
                         CHAR_COUNT: out natural;
                         IS_LAST: out boolean) is

IS_LAST_TIME: boolean := false;
LAST_CHAR_POS: natural := 0;

begin

IS_LAST := false;

if HELP_INFO_SUPPORT.TOP_LINE = null then
  raise HELP_UTILITY.NOTHING_TO_OUTPUT;

else
  if HELP_INFO_SUPPORT.IS_FIRST_TIME then
    HELP_INFO_SUPPORT.CURRENT_LINE := HELP_INFO_SUPPORT.TOP_LINE;
    HELP_INFO_SUPPORT.IS_FIRST_TIME := false;
  end if;

  if LINE'length > HELP_INFO_SUPPORT.CURRENT_LINE.LINE_LENGTH then
    LINE := (1..LINE'length => ' ');
    LINE(1..HELP_INFO_SUPPORT.CURRENT_LINE.LINE_LENGTH)
                           := HELP_INFO_SUPPORT.CURRENT_LINE.
             TEXT_LINE(1..HELP_INFO_SUPPORT.CURRENT_LINE.LINE_LENGTH);
  else
    LINE := HELP_INFO_SUPPORT.CURRENT_LINE.TEXT_LINE
                         (1..LINE'length);
  end if;

  CHAR_COUNT := HELP_INFO_SUPPORT.CURRENT_LINE.LINE_LENGTH;

  if HELP_INFO_SUPPORT.CURRENT_LINE.NEXT_LINE = null then
     HELP_INFO_SUPPORT.CURRENT_LINE := HELP_INFO_SUPPORT.TOP_LINE;
     IS_LAST := true;
     IS_LAST_TIME := true;

  else
    HELP_INFO_SUPPORT.CURRENT_LINE :=
                    HELP_INFO_SUPPORT.CURRENT_LINE.NEXT_LINE;
  end if;
end if;

if IS_LAST_TIME then
  HELP_INFO_SUPPORT.CURRENT_LINE := HELP_INFO_SUPPORT.TOP_LINE;
  HELP_INFO_SUPPORT.PREVIOUS_LINE := HELP_INFO_SUPPORT.TOP_LINE;
  HELP_INFO_SUPPORT.IS_FIRST_TIME := true;
end if;

exception
    when HELP_UTILITY.NOTHING_TO_OUTPUT => raise;

    when others =>
    raise;
end GET_TEXT_LINE;
::::::::::
HELP_INIT.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    :  INITIALIZE
-- Date created :  28 January 1985
-- Last update  :
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     :  This procedure reads in the specified help file into a
----------------: data structure (linked list). Comments are ignored. Any
----------------: input line starting with a digit is considered a new
----------------: level. All other lines are considered text lines.
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------


separate (HELP_UTILITY)
procedure INITIALIZE(HELP_FILE_NAME: in string) is

    PREVIOUS_NODE             : HELP_UTILITY.HELP_LINK := TOP_NODE;
    PREVIOUS_LINE             : HELP_INFO_SUPPORT.TEXT_LINK := null;
    CURRENT_LINE              : HELP_INFO_SUPPORT.TEXT_LINK := null;
    CURRENT_LEVEL             : integer := 1;        -- current topic level
    TOKEN_IS_DIGITS           : boolean := false;  -- indicates if new record
    FIRST_DIGIT_FOUND         : boolean := false; -- topic must be before text
    LINE_BUFFER               : HELP_INFO_SUPPORT.FILE_TEXT_LINE;
    LAST                      : natural := 0; -- # of characters in LINE_BUFFER
    FIRST_TEXT_CHAR           : natural := 0; -- first non-digit character

-- exception

    TEXT_FILE_LEVEL_BAD       : exception;
    TEXT_BEFORE_TOPIC         : exception;

begin

    HELP_UTILITY.HELP_MODE := true;
    HELP_UTILITY.FIRST_HELP_ME_CALL := true;

    text_io.open (HELP_UTILITY.HELP_FILE_TYPE,   -- open the help file
                  text_io.in_file,
                  HELP_FILE_NAME,
                  "");

    while not text_io.end_of_file (HELP_UTILITY.HELP_FILE_TYPE) loop

--    blank the input buffer before using

      LINE_BUFFER := HELP_UTILITY.BLANK_LINE;

      text_io.get_line (HELP_UTILITY.HELP_FILE_TYPE, LINE_BUFFER, LAST);

--    Check if comment input. If so, skip the record.

      if LINE_BUFFER(LINE_BUFFER'first) = '-' and then
            LINE_BUFFER(LINE_BUFFER'first+1) = '-' then
            null;  -- comment read, ignore it

      else

--      Check if new topic read, i.e., digit is first character of record.

        if LINE_BUFFER (LINE_BUFFER'first) in '0' .. '9' then
            TOKEN_IS_DIGITS := true;
            FIRST_DIGIT_FOUND := true;
            FIRST_TEXT_CHAR := 1;

--        loop until all digits found

          while LINE_BUFFER(FIRST_TEXT_CHAR) in '0' .. '9' and
                  FIRST_TEXT_CHAR < HELP_INFO_SUPPORT.MAX_LINE_LENGTH loop

              FIRST_TEXT_CHAR := FIRST_TEXT_CHAR + 1;
          end loop;

--        convert to integer value

          CURRENT_LEVEL := integer'value(LINE_BUFFER
                             (LINE_BUFFER'first .. FIRST_TEXT_CHAR - 1)) -
                             integer'value ("0");

--        skip any blanks between level and keyword

          while LINE_BUFFER(FIRST_TEXT_CHAR) = ' ' loop
            FIRST_TEXT_CHAR := FIRST_TEXT_CHAR + 1;
          end loop;
        end if;

        if TOKEN_IS_DIGITS then

-- NEW TOPIC:
--          Tree structure note: SUBTOPICS links are for children
--                               NEXT_TOPIC links are for siblings
--                               TOP_NODE is the Papa/Mama node
--     Three cases:
--     1) Current topic level is greater than previous topic level
--          (current is subtopic of previous)
--     2) Current topic level is less than previous topic level
--     3) Current topic level is same as previous (or default when first)

          PREVIOUS_LINE := null;
          HELP_UTILITY.CURRENT_NODE := new HELP_UTILITY.HELP_TOPIC ;

          if CURRENT_LEVEL > PREVIOUS_NODE.LEVEL then

--  CASE 1: Current topic level is greater than previous topic level
--          Set double links

--          check that level increases by only one

            if CURRENT_LEVEL - PREVIOUS_NODE.LEVEL > 1 then
              raise TEXT_FILE_LEVEL_BAD;
            end if;

            PREVIOUS_NODE.SUBTOPICS := HELP_UTILITY.CURRENT_NODE;
            HELP_UTILITY.CURRENT_NODE.PARENT := PREVIOUS_NODE;

          elsif CURRENT_LEVEL < PREVIOUS_NODE.LEVEL then

-- CASE 2: Current topic level is less than previous topic level
--         Go back up tree to same level as current.

            while CURRENT_LEVEL < PREVIOUS_NODE.LEVEL loop
                    PREVIOUS_NODE := PREVIOUS_NODE.PARENT;
            end loop;

            PREVIOUS_NODE.NEXT_TOPIC := HELP_UTILITY.CURRENT_NODE;
            HELP_UTILITY.CURRENT_NODE.PARENT := PREVIOUS_NODE;

-- CASE 3: Level has not changed.

          else

--          initial case only. Link off of TOP_NODE's subtopic link

            if PREVIOUS_NODE = HELP_UTILITY.TOP_NODE then
              PREVIOUS_NODE.SUBTOPICS := HELP_UTILITY.CURRENT_NODE;
              HELP_UTILITY.CURRENT_NODE.PARENT := PREVIOUS_NODE;

--          all other cases when same level, link to next_topic.

            else
              PREVIOUS_NODE.NEXT_TOPIC := HELP_UTILITY.CURRENT_NODE;
              HELP_UTILITY.CURRENT_NODE.PARENT := PREVIOUS_NODE;
            end if;
          end if;

--        Save the topics name, name length, and level

          HELP_UTILITY.CURRENT_NODE.NAME(
              1..HELP_INFO_SUPPORT.FILE_TEXT_LINE'last)
                 := LINE_BUFFER (FIRST_TEXT_CHAR .. LAST) &
                     (LAST - FIRST_TEXT_CHAR +
                        2..HELP_INFO_SUPPORT.FILE_TEXT_LINE'last => ' ');
          HELP_UTILITY.CURRENT_NODE.NAME_LENGTH := LAST - FIRST_TEXT_CHAR + 1;
          HELP_UTILITY.CURRENT_NODE.LEVEL := CURRENT_LEVEL;

--        update previous to current and go get next

          PREVIOUS_NODE := HELP_UTILITY.CURRENT_NODE;

-- TEXT INPUT
--      Add text to buffer

        elsif FIRST_DIGIT_FOUND then

--        get a new blank line pointer

          CURRENT_LINE := new HELP_INFO_SUPPORT.TEXT_LINE;

--        save the text

          CURRENT_LINE.TEXT_LINE :=
                  LINE_BUFFER(1..LAST) &
                      (LAST+1 .. HELP_INFO_SUPPORT.FILE_TEXT_LINE'last => ' ');

--        save the length

          if LAST = natural'first then
            CURRENT_LINE.LINE_LENGTH := LAST + 1;
          else
            CURRENT_LINE.LINE_LENGTH := LAST;
          end if;

--        update pointers. First time, link to node, otherwise link to previous

          if PREVIOUS_LINE = null then
             HELP_UTILITY.CURRENT_NODE.TEXT_LINES := CURRENT_LINE;
          else
             PREVIOUS_LINE.NEXT_LINE := CURRENT_LINE;
          end if;

--        update the previous line

          PREVIOUS_LINE := CURRENT_LINE;

        else
          raise TEXT_BEFORE_TOPIC;

        end if;

--       reset flag. Loop back for next

        TOKEN_IS_DIGITS := false;                  -- reset flag
      end if;
    end loop;

    text_io.close (HELP_UTILITY.HELP_FILE_TYPE);

--  set top node to a level of zero. This denotes the top

    HELP_UTILITY.TOP_NODE.LEVEL := 0;
    HELP_UTILITY.CURRENT_NODE := TOP_NODE;
    HELP_UTILITY.INITIALIZED := true;

exception
    when TEXT_FILE_LEVEL_BAD | TEXT_BEFORE_TOPIC =>
         raise HELP_UTILITY.ILLEGAL_FORMAT_FOR_HELP_FILE;

    when text_io.name_error =>
         raise HELP_UTILITY.HELP_FILE_DOES_NOT_EXIST;

    when text_io.status_error | text_io.use_error =>
         raise HELP_UTILITY.CANNOT_OPEN_HELP_FILE;

    when others => raise;
end INITIALIZE;
::::::::::
HELP_ME.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    :  HELP_ME
-- Author       :  BASKETTE
-- Date created :  28 January 1985
-- Last update  :
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     :  This is procedure is the driver of the Help utility.
----------------: It accepts the input from the CLI and determines the
----------------: appropriate action to take.
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------


with CURRENT_EXCEPTION;
separate (HELP_UTILITY)
procedure HELP_ME(CLI_BUFFER: in string) is

TOKEN_COUNT: positive := 1; -- number of tokens in input string
MATCH_COUNT: natural := 0; -- number of token matches at current level
COUNTER: natural := 0; -- loop control
KEYWORD_MATCHES: HELP_UTILITY.HELP_LINK := null; -- list of nodes that match
TOP_SAVE: HELP_UTILITY.HELP_LINK := null; -- first node of KEYWORD_MATCHES
SAME_LEVEL: natural := 0; -- copy of current level of node
MSG_NAME: HELP_INFO_SUPPORT.HELP_INFO_TEXT_LINE;
BLANK_LINE_LENGTH: constant positive := 1;
TEMP_NODE: HELP_UTILITY.HELP_LINK := new HELP_UTILITY.HELP_TOPIC;

-- exceptions

HELP_FILE_NOT_READ: exception;

begin

if not HELP_UTILITY.INITIALIZED then
  raise HELP_FILE_NOT_READ;
end if;

if HELP_UTILITY.HELP_MODE then

-- parse the input string. A table of tokens is returned

HELP_INFO_SUPPORT.PARSE(CLI_BUFFER);

-- if no tokens, a carriage return was entered. move up a level

if HELP_INFO_SUPPORT.NUMBER_OF_TOKENS = 0 then

-- if this is the first time help is entered and no topic is specified,
--    output the first level memu

  if HELP_UTILITY.FIRST_HELP_ME_CALL then
    HELP_UTILITY.OUTPUT_LINE := HELP_UTILITY.BLANK_LINE;
    HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                        BLANK_LINE_LENGTH);
    HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.HEADER_LINE,
                        HELP_UTILITY.HEADER_LINE'length);
    HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                        BLANK_LINE_LENGTH);
    HELP_UTILITY.PRINT_TOPIC_MENU(CURRENT_NODE);

-- else, if at the upper most level and a carriage return is entered, set
--       terminate to true.

  else
    if HELP_UTILITY.CURRENT_NODE = HELP_UTILITY.TOP_NODE then
      HELP_UTILITY.EXIT_HELP;

    else

--    not at top level. back up one level (until level changes)

      SAME_LEVEL := HELP_UTILITY.CURRENT_NODE.LEVEL;

      while HELP_UTILITY.CURRENT_NODE.LEVEL = SAME_LEVEL loop
        HELP_UTILITY.CURRENT_NODE := HELP_UTILITY.CURRENT_NODE.PARENT;
      end loop;
    end if;
  end if;

else

--  loop through the token table returned from PARSE until either:
--       1) "*" found,
--       2) "?" found,
--       3) more than one match is found at a level or
--       4) tokens are exhausted

  loop
    if HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).TOKEN(1..
          HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).LENGTH) = "*"  or
          HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).TOKEN(1..
          HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).LENGTH) = "?" then
      exit;
    end if;

    FIND_KEYWORD(HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).TOKEN,
               HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).LENGTH,
               HELP_UTILITY.CURRENT_NODE,
               KEYWORD_MATCHES,
               MATCH_COUNT);

--  if more than one (ambiguous input) or no match is found, then ignore the
--     remaining tokens, exit loop

    if MATCH_COUNT /= 1 then
      exit;
    end if;

--  if all tokens checked, exit loop

    if TOKEN_COUNT = HELP_INFO_SUPPORT.NUMBER_OF_TOKENS then
      exit;

    else

--  increment the counter and update the current node to the match found

      TOKEN_COUNT := TOKEN_COUNT + 1;
      HELP_UTILITY.CURRENT_NODE := KEYWORD_MATCHES;
    end if;
  end loop;

-- check if all info from current level on down is requested

  if HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).TOKEN(1..
          HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).LENGTH) = "*" then

      TEMP_NODE.all := HELP_UTILITY.CURRENT_NODE.all;
      TEMP_NODE.NEXT_TOPIC := null;
      HELP_UTILITY.DISPLAY_ALL_HELP_INFO(TEMP_NODE);

      if HELP_UTILITY.CURRENT_NODE.SUBTOPICS = null then
         HELP_UTILITY.CURRENT_NODE := HELP_UTILITY.CURRENT_NODE.PARENT ;
      end if;

-- check if an implied help was requested, i.e., menu for current level

  elsif HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).TOKEN(1..
          HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).LENGTH) = "?" then
    HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                        BLANK_LINE_LENGTH);
    HELP_UTILITY.PRINT_TOPIC_TEXT(HELP_UTILITY.CURRENT_NODE);
    HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                        BLANK_LINE_LENGTH);
    HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.ADD_HEADER_LINE,
                        HELP_UTILITY.ADD_HEADER_LINE'length);
    HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                        BLANK_LINE_LENGTH);
    HELP_UTILITY.PRINT_TOPIC_MENU(HELP_UTILITY.CURRENT_NODE);

-- if a match(es) was found, output the info for that match(es)

  elsif MATCH_COUNT /= 0 then
    COUNTER := MATCH_COUNT;  -- counter will be used for loop control
    TOP_SAVE := KEYWORD_MATCHES; -- save the top for later restoration

--  this loop goes through the list (possibly only one) of matches found
--       above. KEYWORD_MATCHES is a linked list of the matches. Each
--       match has its text and menu of subtopics output

    while COUNTER /= 0 loop
      HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                        BLANK_LINE_LENGTH);
      HELP_UTILITY.OUTPUT_LINE := HELP_UTILITY.BLANK_LINE;
      HELP_UTILITY.OUTPUT_LINE(1..KEYWORD_MATCHES.NAME_LENGTH) :=
                         KEYWORD_MATCHES.NAME(1..KEYWORD_MATCHES.NAME_LENGTH);
      HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.OUTPUT_LINE,
                        KEYWORD_MATCHES.NAME_LENGTH);
      HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                        BLANK_LINE_LENGTH);
      HELP_UTILITY.PRINT_TOPIC_TEXT(KEYWORD_MATCHES);

--    check if any subtopics, i.e., if a menu should be output

      if KEYWORD_MATCHES.SUBTOPICS /= null then
        if TOKEN_COUNT < HELP_INFO_SUPPORT.NUMBER_OF_TOKENS then

--        this checks for the case where an ambiguous token was entered followed
--          by an "*". in this case, output all info for all the matches of the
--          ambiguous input

          if HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT + 1).TOKEN(1..
             HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT + 1).LENGTH) = "*"
             then

            HELP_UTILITY.DISPLAY_ALL_HELP_INFO(KEYWORD_MATCHES.SUBTOPICS);
          end if;
        else
          HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                        BLANK_LINE_LENGTH);
          HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.ADD_HEADER_LINE,
                        HELP_UTILITY.ADD_HEADER_LINE'length);
          HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                        BLANK_LINE_LENGTH);
          HELP_UTILITY.PRINT_TOPIC_MENU(KEYWORD_MATCHES);
        end if;
      end if;

      KEYWORD_MATCHES := KEYWORD_MATCHES.NEXT_TOPIC;
      COUNTER := COUNTER - 1;
    end loop;

--  restore the top of the list

    KEYWORD_MATCHES := TOP_SAVE;

--  now we must decide what the next prompt should be (and thus, what the
--      current node should be [or vice versa]).
--      this only matters if one and only one match was found. Else, the
--      current node did not change.

    if MATCH_COUNT = 1 then

--     if there are no subtopics, the prompt should be for the next higher
--        level.

      if KEYWORD_MATCHES.SUBTOPICS = null then

--        if already at the highest level, set current to top

        if KEYWORD_MATCHES.LEVEL <= 1 then
          HELP_UTILITY.CURRENT_NODE := HELP_UTILITY.TOP_NODE;
        else

--        else, move up the links until the level changes. That node will then
--              become the current level

          SAME_LEVEL := KEYWORD_MATCHES.LEVEL;

          while KEYWORD_MATCHES.LEVEL = SAME_LEVEL loop
            KEYWORD_MATCHES := KEYWORD_MATCHES.PARENT;
          end loop;

          HELP_UTILITY.CURRENT_NODE := KEYWORD_MATCHES;
        end if;

      else

--    if there are subtopics, the current node becomes the one found and
--       the user is prompted for subtopic input

        HELP_UTILITY.CURRENT_NODE := KEYWORD_MATCHES;
      end if;
    end if;

  else

--  if no match was found and not a special character (* or ?) then no info
--     for user input request

    HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                        BLANK_LINE_LENGTH);

    if HELP_UTILITY.NO_DOC_LINE'length +
            HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).LENGTH >=
                HELP_INFO_SUPPORT.MAX_LINE_LENGTH then
      MSG_NAME(1..HELP_INFO_SUPPORT.MAX_LINE_LENGTH) :=
                 HELP_UTILITY.NO_DOC_LINE &
                 HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).TOKEN(1..
                 HELP_INFO_SUPPORT.MAX_LINE_LENGTH -
                 HELP_UTILITY.NO_DOC_LINE'length);

    else
      MSG_NAME(1..HELP_INFO_SUPPORT.MAX_LINE_LENGTH) :=
                 HELP_UTILITY.NO_DOC_LINE &
                 HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).TOKEN(1..
                   HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).LENGTH) &
                 (HELP_UTILITY.NO_DOC_LINE'length +
                  HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).LENGTH + 1 ..
                  HELP_INFO_SUPPORT.HELP_INFO_TEXT_LINE'last => ' ');
    end if;

    HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(MSG_NAME,
                  HELP_UTILITY.NO_DOC_LINE'length +
                  HELP_INFO_SUPPORT.INPUT_TOKEN_TABLE(TOKEN_COUNT).LENGTH);
    HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                        BLANK_LINE_LENGTH);
    HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.ADD_HEADER_LINE,
                        HELP_UTILITY.ADD_HEADER_LINE'length);
    HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                        BLANK_LINE_LENGTH);

    if HELP_UTILITY.CURRENT_NODE.LEVEL >= 1 then
      if TOKEN_COUNT > 1 and HELP_UTILITY.CURRENT_NODE.LEVEL /=
                           HELP_UTILITY.CURRENT_NODE.PARENT.LEVEL then
        HELP_UTILITY.CURRENT_NODE := HELP_UTILITY.CURRENT_NODE.PARENT;
      end if;
    end if;

    HELP_UTILITY.PRINT_TOPIC_MENU(HELP_UTILITY.CURRENT_NODE);
    TOKEN_COUNT := HELP_INFO_SUPPORT.NUMBER_OF_TOKENS;
  end if;
end if;

-- before outputting the prompt, check that help was not terminated

if HELP_UTILITY.HELP_MODE then
  HELP_UTILITY.PRINT_CURRENT_PROMPT(HELP_UTILITY.CURRENT_NODE);
end if;

-- indicate that HELP is active

HELP_UTILITY.FIRST_HELP_ME_CALL := false;

end if;

exception
  when HELP_FILE_NOT_READ =>
    raise HELP_UTILITY.HELP_FILE_NOT_INITIALIZED;

  when others => text_io.put_line("Help_me " & CURRENT_EXCEPTION.NAME);
                 HELP_UTILITY.HELP_MODE := false;
                 raise;
end HELP_ME;
::::::::::
HELP_MENU.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    :  PRINT_TOPIC_MENU
-- Date created :  28 January 1985
-- Last update  :
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     :  This procedure will print a list of subtopics (menu) for
----------------: the given node (if any exist). The subtopics are listed
----------------: in two columns.
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------


separate (HELP_UTILITY)
procedure PRINT_TOPIC_MENU (NODE: in HELP_UTILITY.HELP_LINK) is

    TOTAL_NUMBER_OF_TOPICS:   natural := 0;
    NUM_TOPICS_IN_COLUMN_ONE: positive := 1;
    TOPICS_IN_COLUMN_TWO:     boolean := false;
    COL_WIDTH: integer := (HELP_INFO_SUPPORT.MAX_LINE_LENGTH/2) - 1;
    RIGHT_COLUMN_START: integer := COL_WIDTH + 3;
    EVEN:                     boolean := false;
    CURRENT_NODE:             HELP_UTILITY.HELP_LINK := null;
    COL_ONE_NODE:             HELP_UTILITY.HELP_LINK := null;
    COL_TWO_NODE:             HELP_UTILITY.HELP_LINK := null;

begin

CURRENT_NODE := NODE.SUBTOPICS;

-- count the number of subtopics for this node

while CURRENT_NODE /= null loop
  TOTAL_NUMBER_OF_TOPICS := TOTAL_NUMBER_OF_TOPICS + 1;
  CURRENT_NODE:= CURRENT_NODE.NEXT_TOPIC;
end loop;

-- If there is more than one topic, then split the topics into two columns
-- Column one will have the first half and column two the second half.
-- If there are an odd number of topics, column one will have the odd number

if TOTAL_NUMBER_OF_TOPICS /= 0 then
  if TOTAL_NUMBER_OF_TOPICS >= 2 then
    TOPICS_IN_COLUMN_TWO := true;
    NUM_TOPICS_IN_COLUMN_ONE := TOTAL_NUMBER_OF_TOPICS / 2;

-- More than one topic, split the number
-- See if odd number. If so, increment the topic count so odd goes in 1st col.

    if TOTAL_NUMBER_OF_TOPICS /= (TOTAL_NUMBER_OF_TOPICS/2) * 2 then
      NUM_TOPICS_IN_COLUMN_ONE := NUM_TOPICS_IN_COLUMN_ONE + 1;

    else
      EVEN := true;
    end if;
  end if;

-- set the beginning node for each column

  COL_ONE_NODE := NODE.SUBTOPICS;
  CURRENT_NODE := NODE.SUBTOPICS;

  for I in 1..NUM_TOPICS_IN_COLUMN_ONE loop
    COL_TWO_NODE := CURRENT_NODE.NEXT_TOPIC;
    CURRENT_NODE := CURRENT_NODE.NEXT_TOPIC;
  end loop;

  if TOPICS_IN_COLUMN_TWO then
    while COL_TWO_NODE /= null loop
      HELP_UTILITY.OUTPUT_LINE :=
                 HELP_UTILITY.BLANK_LINE; -- blank the line buffer

-- Put first topic in left half of output line
--     if full name will not fit then truncate

      if COL_WIDTH > COL_ONE_NODE.NAME_LENGTH then

--      full name will fit

        HELP_UTILITY.OUTPUT_LINE(1..COL_ONE_NODE.NAME_LENGTH) :=
         COL_ONE_NODE.NAME(1..COL_ONE_NODE.NAME_LENGTH);

      else

--      truncate

        HELP_UTILITY.OUTPUT_LINE(1..COL_WIDTH) :=
         COL_ONE_NODE.NAME(1..COL_WIDTH);
      end if;

-- Put second topic in second half of output line
--     if full name will not fit then truncate

      if COL_WIDTH > COL_TWO_NODE.NAME_LENGTH then

--      full name will fit

        HELP_UTILITY.OUTPUT_LINE(RIGHT_COLUMN_START..RIGHT_COLUMN_START +
               COL_TWO_NODE.NAME_LENGTH - 1 ) :=
                COL_TWO_NODE.NAME(1..COL_TWO_NODE.NAME_LENGTH);
        HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.OUTPUT_LINE,
                     RIGHT_COLUMN_START - 1 + COL_TWO_NODE.NAME_LENGTH);

      else

--      truncate

        HELP_UTILITY.OUTPUT_LINE(RIGHT_COLUMN_START..RIGHT_COLUMN_START +
               COL_WIDTH - 1) :=
                COL_TWO_NODE.NAME(1..COL_WIDTH);
        HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.OUTPUT_LINE,
                     RIGHT_COLUMN_START - 1 + COL_WIDTH);

      end if;

      COL_ONE_NODE := COL_ONE_NODE.NEXT_TOPIC;
      COL_TWO_NODE := COL_TWO_NODE.NEXT_TOPIC;
    end loop;
  end if;

  if not EVEN then

-- Put the odd topic in the output buffer

    HELP_UTILITY.OUTPUT_LINE := HELP_UTILITY.BLANK_LINE;

--  check if name will fit on output line

    if HELP_INFO_SUPPORT.MAX_LINE_LENGTH > COL_ONE_NODE.NAME_LENGTH then

--    name fits

      HELP_UTILITY.OUTPUT_LINE(1..COL_ONE_NODE.NAME_LENGTH) :=
             COL_ONE_NODE.NAME(1..COL_ONE_NODE.NAME_LENGTH);
      HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.OUTPUT_LINE,
                                  COL_ONE_NODE.NAME_LENGTH);

--  truncate

    else
      HELP_UTILITY.OUTPUT_LINE(1..HELP_INFO_SUPPORT.MAX_LINE_LENGTH) :=
             COL_ONE_NODE.NAME(1..HELP_INFO_SUPPORT.MAX_LINE_LENGTH);
      HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.OUTPUT_LINE,
                                  HELP_INFO_SUPPORT.MAX_LINE_LENGTH);
    end if;
  end if;
end if;

exception
    when others => raise;

end PRINT_TOPIC_MENU;
::::::::::
HELP_PROMPT.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    :  PRINT_CURRENT_PROMPT
-- Date created :  28 January 1985
-- Last update  :
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     :  This procedure determines the prompt and outputs it.
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------


separate(HELP_UTILITY)
procedure PRINT_CURRENT_PROMPT(NODE: in HELP_UTILITY.HELP_LINK) is

TEMP_NODE: HELP_UTILITY.HELP_LINK := null;
PROMPT_END: integer := 1; -- number of allowable characters for prompt
SAVE_CURRENT_LEVEL: integer := 0;  -- used in reverse tree traversal
PROMPT_NAME: HELP_INFO_SUPPORT.HELP_INFO_TEXT_LINE := HELP_UTILITY.BLANK_LINE;
BLANK_LINE_LENGTH: constant positive := 1;

begin

-- there are two types of prompts:
-- 1) "topic? "
-- 2) "subtopic? "

-- "topic? " is output when at the highest level (at the top node)

if NODE = HELP_UTILITY.TOP_NODE then
  HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                                      BLANK_LINE_LENGTH);
  HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.TOPIC_LINE,
                                      HELP_UTILITY.TOPIC_LINE'length);

else

-- when at a lower level output the topic name(s) followed by "subtopic? "

  TEMP_NODE := NODE;
  SAVE_CURRENT_LEVEL := NODE.LEVEL;

-- put the prompt "subtopic? " in the buffer

  PROMPT_NAME(1..HELP_UTILITY.SUBTOPIC_LINE'length) :=
             HELP_UTILITY.SUBTOPIC_LINE;
  PROMPT_END := HELP_INFO_SUPPORT.MAX_LINE_LENGTH -
                     HELP_UTILITY.SUBTOPIC_LINE'length - 1;

-- now put the name of the current node in the buffer before the prompt

  PROMPT_NAME(1..TEMP_NODE.NAME_LENGTH +
         HELP_INFO_SUPPORT.MAX_LINE_LENGTH - PROMPT_END + 1) :=
              TEMP_NODE.NAME(1..TEMP_NODE.NAME_LENGTH) & ' ' &
                   PROMPT_NAME(1..HELP_INFO_SUPPORT.MAX_LINE_LENGTH -
                          PROMPT_END);

  PROMPT_END := PROMPT_END - TEMP_NODE.NAME_LENGTH - 1;

-- do a reverse tree traversal starting at the current node. if a level
--  changes, put that node's name in the output string

  while TEMP_NODE.LEVEL > 0 loop
    if SAVE_CURRENT_LEVEL /= TEMP_NODE.LEVEL then
      SAVE_CURRENT_LEVEL := TEMP_NODE.LEVEL;

      if SAVE_CURRENT_LEVEL > 0 then

--      if the name will not fit then exit and go with what we have

        if TEMP_NODE.NAME_LENGTH + 1 > PROMPT_END then
          exit;
        end if;

        PROMPT_NAME(1..TEMP_NODE.NAME_LENGTH +
               HELP_INFO_SUPPORT.MAX_LINE_LENGTH - PROMPT_END + 1) :=
                    TEMP_NODE.NAME(1..TEMP_NODE.NAME_LENGTH) & ' ' &
                    PROMPT_NAME(1..HELP_INFO_SUPPORT.MAX_LINE_LENGTH -
                           PROMPT_END);

        PROMPT_END := PROMPT_END - TEMP_NODE.NAME_LENGTH - 1;
      end if;
    end if;

    TEMP_NODE := TEMP_NODE.PARENT;
  end loop;

  HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(HELP_UTILITY.BLANK_LINE,
                                      BLANK_LINE_LENGTH);
  HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(PROMPT_NAME,
                      HELP_INFO_SUPPORT.MAX_LINE_LENGTH - PROMPT_END - 1);

end if;

exception
    when others => raise;

end PRINT_CURRENT_PROMPT;
::::::::::
HELP_RESET.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    :  RESET_HELP
-- Date created :  04 March 1985
-- Last update  :
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     :  The procedure sets the help mode flag to true and
----------------: resets the current node pointer to the top node of the
----------------: tree.
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------


separate (HELP_UTILITY)
procedure RESET_HELP is

begin

HELP_UTILITY.CURRENT_NODE := HELP_UTILITY.TOP_NODE;

-- set HELP_MODE to on

HELP_UTILITY.HELP_MODE := true;
HELP_UTILITY.FIRST_HELP_ME_CALL := true;

end RESET_HELP;
::::::::::
HELP_TEXT.ADA
::::::::::
-------------------------PROLOGUE---------------------------------------
--                                                                    -*
-- Unit name    :  PRINT_TOPIC_TEXT
-- Date created :  28 January 1985
-- Last update  :
--                                                                    -*
------------------------------------------------------------------------
--                                                                    -*
-- Abstract     : This procedure prints the text assoicated with the
----------------: given node.
--                                                                    -*
------------------------------------------------------------------------
--
-- Mnemonic     :
-- Name         :
-- Release date :
------------------ Revision history ------------------------------------
--
-- DATE  AUTHOR   HISTORY
--
--
--
--------------------END-PROLOGUE----------------------------------------


separate (HELP_UTILITY)
procedure PRINT_TOPIC_TEXT (NODE: in HELP_UTILITY.HELP_LINK) is

   CURRENT_LINE: HELP_INFO_SUPPORT.TEXT_LINK;

begin

CURRENT_LINE := NODE.TEXT_LINES;

while CURRENT_LINE /= null loop
  HELP_INFO_SUPPORT.APPEND_TO_DISPLAY(CURRENT_LINE.TEXT_LINE,
                                      CURRENT_LINE.LINE_LENGTH);
  CURRENT_LINE := CURRENT_LINE.NEXT_LINE;
end loop;

exception
    when others => raise;
end PRINT_TOPIC_TEXT;
::::::::::
HELP_FILE_SPEC.ADA
::::::::::
----------------------------------------------------------------------------
--
-- Abstract   : This package controls calls to the HELP_UTILITY package.
--            : It also handles the Help output to the screen.
--            : The exceptions are propagated up to the calling routine.
--
----------------------------------------------------------------------------
package HELP is

    subtype LEVEL_TYPE is string(1..10) ;

    MERGE_HELP : constant LEVEL_TYPE := "HELP MERGE";   -- call is made
                                                        -- from Merge

    LIST_HELP  : constant LEVEL_TYPE := "HELP LIST ";   -- call is made
                                                        -- from List

    SPELL_HELP : constant LEVEL_TYPE := "HELP SPELL";   -- call is made
                                                        -- from Spell

    HELP_HELP  : constant LEVEL_TYPE := "HELP      ";   -- call from
                                                        -- top-level of Speller

    QUIT_HELP  : constant LEVEL_TYPE := "HELP QUIT ";   -- call is made
                                                        -- from Quit

    procedure HELP_SCREEN (LEVEL      : LEVEL_TYPE);


 -- exceptions

    HELP_OPEN_ERROR : exception;      -- HELP_FILE.INI cannot be opened
    HELP_FILE_ERROR : exception;      -- HELP_FILE.INI does not exist
    HELP_FORMAT_ERROR : exception;    -- HELP_FILE.INI has been modified
                                      --   and the format is illegal

end HELP;
::::::::::
HELP_FILE_BODY.ADA
::::::::::
--------------------------------------------------------------------------
--
--  Abstract   : This package body allows for the output of Help
--             : information (procedure OUTPUT_HELP_INFO) obtained
--             : when calls are made to the HELP_UTILITY package
--             : from procedure HELP_SCREEN.
--
---------------------------------------------------------------------------
with MACHINE_DEPENDENCIES;
with TERMINAL_INTERFACE;
with HELP_UTILITY;

package body HELP is

 procedure HELP_SCREEN (LEVEL: LEVEL_TYPE) is


 -- Constants and variables

   HELP_TOPIC : string (1..80);          -- string containing user input
   TOPIC_LENGTH : natural;
   FIRST_CALL: BOOLEAN := TRUE;          -- Initialization flag

   procedure  OUTPUT_HELP_INFO is

     HELP_INFO  : string (1..80);
     HELP_INFO_LENGTH: natural;
     IS_LAST : BOOLEAN;

   begin

     TERMINAL_INTERFACE.NEW_LINE;
     HELP_UTILITY.GET_TEXT_LINE(HELP_INFO,HELP_INFO_LENGTH,IS_LAST);

     while not IS_LAST loop
        TERMINAL_INTERFACE.PUT_LINE(HELP_INFO);
        TERMINAL_INTERFACE.NEW_LINE;
        HELP_UTILITY.GET_TEXT_LINE(HELP_INFO,HELP_INFO_LENGTH,IS_LAST);
     end loop;

     TERMINAL_INTERFACE.PUT(HELP_INFO(1..HELP_INFO_LENGTH));


   end OUTPUT_HELP_INFO;

 begin       -- begin procedure HELP_SCREEN

 --
 -- Initialize HELP_FILE the first time through
 --

     if FIRST_CALL then
        HELP_UTILITY.INITIALIZE(MACHINE_DEPENDENCIES.HELP_FILE);
        FIRST_CALL := FALSE;
     end if;
 --
 -- Clear screen
 --

    TERMINAL_INTERFACE.NEW_PAGE;

 --
 -- Make initial call to HELP entering at level call was made

       HELP_UTILITY.HELP_ME(LEVEL);

    --
    -- Handle other help requests
    --


       while not HELP_UTILITY.HELP_IS_TERMINATED loop

        OUTPUT_HELP_INFO;
        TERMINAL_INTERFACE.GET_LINE(HELP_TOPIC,TOPIC_LENGTH);
        HELP_UTILITY.HELP_ME(HELP_TOPIC(1..TOPIC_LENGTH));

       end loop;

     TERMINAL_INTERFACE.NEW_LINE;
     HELP_UTILITY.RESET_HELP;     -- Make sure you reset HELP for future
                                  -- entries into Help_screen


   exception
        when HELP_UTILITY.HELP_FILE_DOES_NOT_EXIST => raise HELP_FILE_ERROR;

        when HELP_UTILITY.CANNOT_OPEN_HELP_FILE => raise HELP_OPEN_ERROR;

        when HELP_UTILITY.ILLEGAL_FORMAT_FOR_HELP_FILE =>
                                               raise HELP_FORMAT_ERROR;

   end HELP_SCREEN;

 end HELP;
::::::::::
GET_UI_SPEC.ADA
::::::::::
--------------------------------------------------------------------------
-- Abstract   : This package will read the SPELL_DATA.INI file to obtain
--            : the initial processing values.  If the file cannot be
--            : read, the user of the package will have to obtain the
--            : information else where.
--------------------------------------------------------------------------
-- Parameters : Not applicable
--
--------------------------------------------------------------------------
-- Algorithm  : (An optional paragraph describing any special algorithms
--               used by the package or routine.)
--------------------------------------------------------------------------
with MACHINE_DEPENDENCIES,
     DICTIONARY_MANAGER;
package GET_USER_INFO is

    NUMBER_OF_USER_DICTIONARIES : constant := 6;

    subtype NAME_RANGE is POSITIVE
                            range 1 .. MACHINE_DEPENDENCIES
                                        .MAX_FILE_NAME_LENGTH;

    type MODE_TYPE is (ENABLED, DISABLED);

    type DICTIONARY_NAME is
        record
            NAME   : STRING (NAME_RANGE);
            LENGTH : NATURAL := 0;
            PTR    : DICTIONARY_MANAGER.DICTIONARY_PTR;
            MODE   : MODE_TYPE := DISABLED;
        end record;

    type FILE_NAME_TYPE is
        record
            NAME   : STRING (NAME_RANGE);
            LENGTH : NATURAL := 0;
        end record;

    type USER_DICTIONARIES is array (POSITIVE
                                       range POSITIVE'FIRST ..
                                             NUMBER_OF_USER_DICTIONARIES)
                                     of DICTIONARY_NAME;

    type DICTIONARY_TYPE is
        record
            NUMBER_OF_ENTRIES : NATURAL
                                  range NATURAL'FIRST ..
                                        NUMBER_OF_USER_DICTIONARIES
                                        := NATURAL'FIRST;

            NAMES             : USER_DICTIONARIES;
            MODE              : MODE_TYPE := DISABLED;
        end record;
    type USER_INFO_TYPE is
        record
            DOCUMENT      : FILE_NAME_TYPE;
            CORRECTED_DOC : FILE_NAME_TYPE;
            WORD_LIST     : FILE_NAME_TYPE;
            MODE          : MODE_TYPE := ENABLED;
            MASTER        : BOOLEAN := TRUE;
            ACRONYM       : BOOLEAN := FALSE;
            USER_DICT     : DICTIONARY_TYPE;
        end record;


    procedure GET_INFO (USER_INFO  : out USER_INFO_TYPE;
                        SUCCESSFUL : out BOOLEAN);

    procedure SAVE_INFO (USER_INFO : USER_INFO_TYPE);

    procedure COLLECT_USER_INFO (USER_INFO : in out USER_INFO_TYPE);

end GET_USER_INFO;
::::::::::
GET_UI_BODY.ADA
::::::::::
with SEQUENTIAL_IO,
     TERMINAL_INTERFACE;

package body GET_USER_INFO is

    package READ_INFO is new SEQUENTIAL_IO (USER_INFO_TYPE);

--****************************************************************
--****************************************************************

--------------------------------------------------------------------------
-- Abstract   : This operation will open the SPELL_DATA.INI file.
--            : If the open fails because the file is not present
--            : then set the SUCCESSFUL flag to false and terminate.
--            : Otherwise read in the user information.
--------------------------------------------------------------------------
-- Parameters : USER_INFO  : out USER_INFO_TYPE; this is the record
--            : which will containt the operational values.
--            :
--            : SUCCESSFUL : out BOOLEAN; This will indicate wheather or
--            : not the file was present and the information obtained.
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

procedure GET_INFO (USER_INFO  : out USER_INFO_TYPE;
                    SUCCESSFUL : out BOOLEAN) is

    INPUT : READ_INFO.FILE_TYPE;


begin
    READ_INFO.OPEN (INPUT, READ_INFO.IN_FILE,
                    MACHINE_DEPENDENCIES.INFO_FILE);
    READ_INFO.READ (INPUT, USER_INFO);
    SUCCESSFUL := TRUE;
    READ_INFO.CLOSE (INPUT);
exception
    when others =>
        SUCCESSFUL := FALSE;
end GET_INFO;



--****************************************************************
--****************************************************************


--------------------------------------------------------------------------
-- Abstract   : This operation will replace USER_INFO into
--            : the SPELLDAT.INI
--            : file.
--------------------------------------------------------------------------
-- Parameters : USER_INFO  : out USER_INFO_TYPE; this is the record
--            : which
--            : will containt the operational values.
--            :
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

procedure SAVE_INFO (USER_INFO : USER_INFO_TYPE) is

    OUTPUT : READ_INFO.FILE_TYPE;

begin
    READ_INFO.CREATE(OUTPUT, READ_INFO.OUT_FILE,
                    MACHINE_DEPENDENCIES.INFO_FILE);
    READ_INFO.WRITE (OUTPUT, USER_INFO);
    READ_INFO.CLOSE (OUTPUT);
end SAVE_INFO;



--****************************************************************
--****************************************************************


--------------------------------------------------------------------------
-- Abstract   : This operation will collect the necessary information
--            : needed to operate this tool.  The information will come
--            : from the user, and will be stored in the USER_INFO
--            : record.
--------------------------------------------------------------------------
-- Parameters : USER_INFO : out USER_INFO_TYPE;
--            : This value is a record containing the following fields:
--            :               DOCUMENT
--            :               CORRECTED_DOC
--            :               WORD_LIST
--            :               MODE
--            :               MASTER
--            :               ACRONYM
--            :               USER_DICT
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

procedure COLLECT_USER_INFO (USER_INFO : in out USER_INFO_TYPE) is


    UPPER_YES        : constant CHARACTER := 'Y';
    LOWER_YES        : constant CHARACTER := 'y';
    UPPER_NO         : constant CHARACTER := 'N';
    LOWER_NO         : constant CHARACTER := 'n';
    FOUND_IN_THE_LIST : BOOLEAN;
    CHARACTERS_READ   : NATURAL;
    USER_RESPONSE     : STRING (NAME_RANGE);


-----------------------------------------------------------------
--
--
--  The following outline the prompts which must be responded
--  to by the user.
--
--
-----------------------------------------------------------------


    MASK_LINE1  : constant STRING :=
                  "Enter text file name of the document to be checked: ";

    MASK_LINE2  : constant STRING :=
                  "Enter text file name of the corrected document";

    MASK_LINE3  : constant STRING :=
                  "Enter text file name which will contain the suspect words";

    MASK_LINE4  : constant STRING :=
                  "Do you wish to enable the CORRECTOR? <Y/N>";

    MASK_LINE5  : constant STRING :=
                  "Do you wish to disable the CORRECTOR? <Y/N>";

    MASK_LINE6  : constant STRING :=
                  "Do you wish to enable the MASTER dictionary ? <Y/N> ";

    MASK_LINE7  : constant STRING :=
                  "Do you wish to disable the MASTER dictionary ? <Y/N> ";

    MASK_LINE8  : constant STRING :=
                  "Do you wish to enable the ACRONYM Dictionary? <Y/N> ";

    MASK_LINE9  : constant STRING :=
                  "Do you wish to disable the ACRONYM Dictionary? <Y/N> ";

    MASK_LINE10 : constant STRING :=
                  "Do you wish to enable a User-defined Dictionary? <Y/N> ";

    MASK_LINE11 : constant STRING := "Enter User Dictionary name: ";

    MASK_LINE12 : constant STRING :=
               "Do you wish to enable another User-defined Dictionary? <Y/N> ";

begin

    TERMINAL_INTERFACE.NEW_PAGE;

-------------------------------------------------------
--   Enter text file name of the document to be checked
-------------------------------------------------------

    loop

       TERMINAL_INTERFACE.PUT_LINE (MASK_LINE1);
       TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE, CHARACTERS_READ);

       if CHARACTERS_READ >= USER_RESPONSE'FIRST then
          USER_INFO.DOCUMENT.NAME := USER_RESPONSE;
          USER_INFO.DOCUMENT.LENGTH := CHARACTERS_READ;
          exit;
       end if;
    end loop;

-----------------------------------------------------------------
--      Do you wish to disable the CORRECTOR? <Y/N>
-----------------------------------------------------------------

    if USER_INFO.MODE = ENABLED then

        TERMINAL_INTERFACE.PUT_LINE (MASK_LINE5);
        TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE, CHARACTERS_READ);

        if USER_RESPONSE (USER_RESPONSE'FIRST) = UPPER_YES or else
           USER_RESPONSE (USER_RESPONSE'FIRST) = LOWER_YES then
            USER_INFO.MODE := DISABLED;

           USER_INFO.CORRECTED_DOC.LENGTH := 0;
        end if;

    else

------------------------------------------------------------------
--     Do you wish to enable the CORRECTOR? <Y/N>
------------------------------------------------------------------

        TERMINAL_INTERFACE.PUT_LINE (MASK_LINE4);
        TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE, CHARACTERS_READ);

        if USER_RESPONSE (USER_RESPONSE'FIRST) = UPPER_YES or else
           USER_RESPONSE (USER_RESPONSE'FIRST) = LOWER_YES then
            USER_INFO.MODE := ENABLED;

           USER_INFO.WORD_LIST.LENGTH := 0;

        end if;

    end if;


   if USER_INFO.MODE = GET_USER_INFO.ENABLED then

-------------------------------------------------------
--  Enter text file name of the corrected document
-------------------------------------------------------

    loop
        TERMINAL_INTERFACE.PUT_LINE (MASK_LINE2);
        TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE, CHARACTERS_READ);

        if CHARACTERS_READ = USER_INFO.DOCUMENT.LENGTH
           and then
               USER_RESPONSE(USER_RESPONSE'FIRST .. CHARACTERS_READ)
               = USER_INFO.DOCUMENT.NAME(USER_INFO.DOCUMENT.NAME'FIRST ..
                                         USER_INFO.DOCUMENT.LENGTH)
           then
               TERMINAL_INTERFACE.PUT_LINE
                   ("The corrected document name must be unique.");
        elsif
            CHARACTERS_READ >= USER_RESPONSE'FIRST then
            USER_INFO.CORRECTED_DOC.NAME := USER_RESPONSE;
            USER_INFO.CORRECTED_DOC.LENGTH := CHARACTERS_READ;
            exit;
        else
            null;
        end if;
    end loop;
   end if;

------------------------------------------------------------------
--  Enter text file name which will contain the suspect words
------------------------------------------------------------------
    loop
        TERMINAL_INTERFACE.PUT_LINE (MASK_LINE3);
        TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE, CHARACTERS_READ);

        if CHARACTERS_READ >= USER_RESPONSE'FIRST then
           USER_INFO.WORD_LIST.NAME := USER_RESPONSE;
           USER_INFO.WORD_LIST.LENGTH := CHARACTERS_READ;
        end if;

        if USER_INFO.WORD_LIST.LENGTH = USER_INFO.DOCUMENT.LENGTH
           and then USER_INFO.WORD_LIST.NAME(USER_INFO.WORD_LIST.NAME'FIRST ..
                                             USER_INFO.WORD_LIST.LENGTH)
           = USER_INFO.DOCUMENT.NAME(USER_INFO.DOCUMENT.NAME'FIRST ..
                                     USER_INFO.DOCUMENT.LENGTH)
           then TERMINAL_INTERFACE.PUT_LINE
                   ("This file name must be unique.");

        elsif USER_INFO.WORD_LIST.LENGTH = USER_INFO.CORRECTED_DOC.LENGTH
             and then USER_INFO.WORD_LIST.NAME
                              (USER_INFO.WORD_LIST.NAME'FIRST ..
                               USER_INFO.WORD_LIST.LENGTH)
             = USER_INFO.CORRECTED_DOC.NAME
                              (USER_INFO.CORRECTED_DOC.NAME'FIRST ..
                               USER_INFO.CORRECTED_DOC.LENGTH)
        then TERMINAL_INTERFACE.PUT_LINE
                ("This file name must be unique.");
        else exit;
        end if;
    end loop;

    if USER_INFO.MASTER then

-------------------------------------------------------------------
--      Do you wish to disable the MASTER dictionary ? <Y/N>
-------------------------------------------------------------------

        TERMINAL_INTERFACE.PUT_LINE (MASK_LINE7);
        TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE, CHARACTERS_READ);

        if USER_RESPONSE (USER_RESPONSE'FIRST) = UPPER_YES or else
           USER_RESPONSE (USER_RESPONSE'FIRST) = LOWER_YES then
            USER_INFO.MASTER := FALSE;
        end if;

    else

-----------------------------------------------------------------
--      Do you wish to enable the MASTER dictionary ? <Y/N>
-----------------------------------------------------------------

        TERMINAL_INTERFACE.PUT_LINE (MASK_LINE6);
        TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE, CHARACTERS_READ);

        if USER_RESPONSE (USER_RESPONSE'FIRST) = UPPER_YES or else
           USER_RESPONSE (USER_RESPONSE'FIRST) = LOWER_YES then
            USER_INFO.MASTER := TRUE;
        end if;

    end if;

    if USER_INFO.ACRONYM then

-----------------------------------------------------------------
--     Do you wish to disable the ACRONYM Dictionary? <Y/N>
-----------------------------------------------------------------

        TERMINAL_INTERFACE.PUT_LINE (MASK_LINE9);
        TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE, CHARACTERS_READ);

        if USER_RESPONSE (USER_RESPONSE'FIRST) = UPPER_YES or else
           USER_RESPONSE (USER_RESPONSE'FIRST) = LOWER_YES then
            USER_INFO.ACRONYM := FALSE;
        end if;

    else

-----------------------------------------------------------------
--      Do you wish to enable the ACRONYM Dictionary? <Y/N>
-----------------------------------------------------------------

        TERMINAL_INTERFACE.PUT_LINE (MASK_LINE8);
        TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE, CHARACTERS_READ);

        if USER_RESPONSE (USER_RESPONSE'FIRST) = UPPER_YES or else
           USER_RESPONSE (USER_RESPONSE'FIRST) = LOWER_YES then
                       USER_INFO.ACRONYM := TRUE;
        end if;


    end if;

------------------------------------------------------------------
--  Do you wish to enable a User-defined Dictionary? <Y/N>
------------------------------------------------------------------

    TERMINAL_INTERFACE.PUT_LINE (MASK_LINE10);
    TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE, CHARACTERS_READ);

    if CHARACTERS_READ >= USER_RESPONSE'FIRST and
       (USER_RESPONSE (USER_RESPONSE'FIRST) = UPPER_YES or
       USER_RESPONSE (USER_RESPONSE'FIRST) = LOWER_YES) then

        USER_INFO.USER_DICT.NUMBER_OF_ENTRIES := 1;

        USER_INFO.USER_DICT.MODE := ENABLED;

----------------------------------------------
--        disable all user dictionaries
----------------------------------------------

        for I in 1 .. NUMBER_OF_USER_DICTIONARIES loop
            USER_INFO.USER_DICT.NAMES(I).MODE := DISABLED;
        end loop;


-------------------------------------------------------------------
--               Enter User Dictionary name:
-------------------------------------------------------------------

        TERMINAL_INTERFACE.PUT_LINE (MASK_LINE11);

        TERMINAL_INTERFACE.GET_LINE
           (USER_RESPONSE,CHARACTERS_READ);

-----------------------------------------------------
--     Insert the dictionary at the head of the list
-----------------------------------------------------

        USER_INFO.USER_DICT.NAMES
            (USER_INFO.USER_DICT.NUMBER_OF_ENTRIES).NAME := USER_RESPONSE;

        USER_INFO.USER_DICT.NAMES
            (USER_INFO.USER_DICT.NUMBER_OF_ENTRIES).LENGTH := CHARACTERS_READ;

----------------------------------------------------
--      Enable it as well
----------------------------------------------------

        USER_INFO.USER_DICT.NAMES
                  (USER_INFO.USER_DICT.NUMBER_OF_ENTRIES).MODE
                                   := ENABLED;
-------------------------------------------------------------
--    Do you wish to enable another User-defined Dictionary?
-------------------------------------------------------------

        TERMINAL_INTERFACE.PUT_LINE (MASK_LINE12);
        TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE, CHARACTERS_READ);

        if CHARACTERS_READ < USER_RESPONSE'FIRST or
           USER_RESPONSE (USER_RESPONSE'FIRST) = UPPER_NO or
           USER_RESPONSE (USER_RESPONSE'FIRST) = LOWER_NO then
            null;
        else
            TERMINAL_INTERFACE.PUT_LINE ("Enter <cr> to terminate.");
            loop
                USER_INFO.USER_DICT.NUMBER_OF_ENTRIES :=
                  USER_INFO.USER_DICT.NUMBER_OF_ENTRIES + 1;

                TERMINAL_INTERFACE.PUT_LINE (MASK_LINE11);

                TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE,CHARACTERS_READ);

                exit when CHARACTERS_READ = 0;

                FOUND_IN_THE_LIST := FALSE;

                for I in USER_INFO.USER_DICT.NUMBER_OF_ENTRIES
                         .. NUMBER_OF_USER_DICTIONARIES loop

                   if CHARACTERS_READ = USER_INFO.USER_DICT.NAMES(I).LENGTH

                   and then

                       USER_RESPONSE(USER_RESPONSE'FIRST ..
                                     CHARACTERS_READ) =
                       USER_INFO.USER_DICT.NAMES(I).NAME
                                 (USER_INFO.USER_DICT.NAMES(I).NAME'FIRST ..
                                  USER_INFO.USER_DICT.NAMES(I).LENGTH)

-----------------------------------------------------
--        if it is in the list simply enable it
-----------------------------------------------------

                   then USER_INFO.USER_DICT.NAMES(I).MODE := ENABLED ;
                        FOUND_IN_THE_LIST := TRUE;
                        exit;
                   end if;
                end loop;

                if not FOUND_IN_THE_LIST then

--------------------------------------------------------------
--     Insert the dictionary at the NEW head of the list
--------------------------------------------------------------

                    USER_INFO.USER_DICT.NAMES
                        (USER_INFO.USER_DICT.NUMBER_OF_ENTRIES)
                            .NAME :=USER_RESPONSE;

                    USER_INFO.USER_DICT.NAMES
                        (USER_INFO.USER_DICT.NUMBER_OF_ENTRIES)
                            .LENGTH := CHARACTERS_READ;

----------------------------------------------------
--      Enable it as well
----------------------------------------------------

                    USER_INFO.USER_DICT.NAMES
                          (USER_INFO.USER_DICT.NUMBER_OF_ENTRIES).MODE
                                   := ENABLED;
                end if;

                exit when USER_INFO.USER_DICT.NUMBER_OF_ENTRIES =
                          NUMBER_OF_USER_DICTIONARIES;

            end loop;
        end if;
    else
         USER_INFO.USER_DICT.MODE := DISABLED;

         for I in 1 .. NUMBER_OF_USER_DICTIONARIES  loop
                USER_INFO.USER_DICT.NAMES(I).MODE := DISABLED;
         end loop;

         USER_INFO.USER_DICT.NUMBER_OF_ENTRIES := 0;

    end if;

end COLLECT_USER_INFO;

--***************************************************************
--***************************************************************

end GET_USER_INFO;
::::::::::
UTIL_SPEC.ADA
::::::::::

with TEXT_IO;

package UTILITIES is

    TERMINAL_DEVICE : constant STRING := "";

    WANTS_HELP      : constant CHARACTER := '?';

    LENGTH          : NATURAL := TERMINAL_DEVICE'LENGTH;

    NEEDS_HELP          : exception;

    INVALID_INPUT_FILE  : exception;

    INVALID_OUTPUT_FILE : exception;

    ABANDON             : exception;

    procedure LIST (INPUT_FILE, OUTPUT_FILE : STRING);


    procedure MERGE (DICTIONARY_A,
                     DICTIONARY_B,
                     DICTIONARY_C : in out TEXT_IO.FILE_TYPE);

    procedure GET_DICTIONARY_NAME
                 (DICTIONARY_NAME : out STRING;
                  NAME_LENGTH     : out NATURAL);

    procedure OPEN (FILE_NAME   : STRING;
                    OPENED_FILE : in out TEXT_IO.FILE_TYPE);

    procedure CREATE (FILE_NAME    : STRING;
                      CREATED_FILE : in out TEXT_IO.FILE_TYPE);
end UTILITIES;
::::::::::
UTIL_BODY.ADA
::::::::::
with MACHINE_DEPENDENCIES,
     EQUALITY_OPERATOR,
     TERMINAL_INTERFACE,
     TEXT_IO,
     SINGLY_LINKED_LIST,
     TOKEN_DEFINITION;



package body UTILITIES is

--****************************************************************
--****************************************************************


-------------------------------------------------------------------------
-- Abstract   : This operation will obtain a file name from the user.
--
--------------------------------------------------------------------------
-- Parameters : DICTIONARY_NAME : out STRING; is the name of the
-- dictionary
--            : file.
--            :
--            : NAME_LENGTH : out NATURAL; is the number of characters
-- in
--            : the DICTIONARY_NAME.
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

    procedure GET_DICTIONARY_NAME (DICTIONARY_NAME : out STRING;
                                   NAME_LENGTH     : out NATURAL) is

        INPUT_STRING : STRING
                         (1 .. MACHINE_DEPENDENCIES.FILE_LINE_LENGTH);

        LENGTH       : NATURAL := 0;

        INDEX        : NATURAL := 1;

        BLANK        : constant CHARACTER := ' ';

    begin

        DICTIONARY_NAME := (DICTIONARY_NAME'RANGE => ' ');

----------------------------------------------------------------
-- if the user enters a space (blank value) then the
-- DICTIONARY_NAME
-- will be assigned the default value TERMINAL_DEVICE.  If
-- the KEY_BOARD_RESPONSE is a '?' then help is being requested.
-----------------------------------------------------------------

        TERMINAL_INTERFACE.GET_LINE (INPUT_STRING, LENGTH);

        if LENGTH = INPUT_STRING'FIRST - 1 then
            raise ABANDON;
        else

            for I in INPUT_STRING'FIRST .. LENGTH loop
                if INPUT_STRING (I) = WANTS_HELP then
                    raise NEEDS_HELP;
                end if;
            end loop;

            loop
                if INPUT_STRING (INDEX) = BLANK then
                    null;
                else

                    NAME_LENGTH := LENGTH - INDEX + 1;

                    DICTIONARY_NAME
                       (DICTIONARY_NAME'FIRST .. LENGTH - INDEX + 1) :=
                      INPUT_STRING (INDEX .. LENGTH);
                    exit;

                end if;

                INDEX := INDEX + 1;

                if INDEX > LENGTH then

                    NAME_LENGTH := TERMINAL_DEVICE'LENGTH;

                    DICTIONARY_NAME (TERMINAL_DEVICE'RANGE) :=
                      TERMINAL_DEVICE;

                    exit;

                end if;

            end loop;

        end if;
    end GET_DICTIONARY_NAME;


--****************************************************************
--****************************************************************

-------------------------------------------------------------------------
-- Abstract   : This operation will list out a user dicitonary to a
-- file.
--
--------------------------------------------------------------------------
-- Parameters : INPUT_FILE,OUTPUT_FILE : STRING;
--              Both parameters are string names of user files.
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

    procedure LIST (INPUT_FILE, OUTPUT_FILE : STRING) is

        NUMBER_OF_CHARACTERS : NATURAL;
        -- number of spaces
        TAB_WIDTH : constant STRING := "     ";   -- between columns
                                                  -- on output.
        MARGIN    : constant NATURAL := TAB_WIDTH'LENGTH;

        TOKEN     : TOKEN_DEFINITION.TOKEN_TYPE;

        INPUT     : TEXT_IO.FILE_TYPE;

        OUTPUT    : TEXT_IO.FILE_TYPE;

------------------------------
-- Local helper procedure
-- to list multiple words per
-- output line.
------------------------------

--------------------------------------------------------------------------
-- Abstract   : This operation will output to a file using a column and
--            : and page format.  The formats are calculated based on
--            : constants declared in the machine dependencies package.
--------------------------------------------------------------------------
-- Parameters : INPUT and OUTPUT are opened files.
--
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

        procedure OUTPUT_MULTIPLE_COLUMNS
                     (INPUT, OUTPUT : in out TEXT_IO.FILE_TYPE) is
        begin
            if TEXT_IO.END_OF_FILE (INPUT) then
                null;
            else
                TOKEN.WORD := (TOKEN.WORD'RANGE => ' ');
                TEXT_IO.GET_LINE (INPUT, TOKEN.WORD, TOKEN.LENGTH);
                TEXT_IO.PUT (OUTPUT, TOKEN.WORD (TOKEN.WORD'RANGE));
                loop
                    exit when TEXT_IO.END_OF_FILE (INPUT);
                    TOKEN.WORD := (TOKEN.WORD'RANGE => ' ');
                    TEXT_IO.GET_LINE (INPUT, TOKEN.WORD, TOKEN.LENGTH);
                    if NATURAL (TEXT_IO.COL (OUTPUT)) +
                       TOKEN_DEFINITION.TOKEN_LENGTH + MARGIN >
                       MACHINE_DEPENDENCIES.OUTPUT_PAGE_WIDTH then
                        TEXT_IO.NEW_LINE (OUTPUT);
                        if NATURAL (TEXT_IO.LINE (OUTPUT)) >
                           MACHINE_DEPENDENCIES.OUTPUT_PAGE_LENGTH then
                            TEXT_IO.NEW_PAGE (OUTPUT);
                        end if;

                        TEXT_IO.PUT
                           (OUTPUT, TOKEN.WORD (TOKEN.WORD'RANGE));

                    else
                        TEXT_IO.PUT (OUTPUT, TAB_WIDTH);
                        TEXT_IO.PUT
                           (OUTPUT, TOKEN.WORD (TOKEN.WORD'RANGE));
                    end if;
                end loop;
            end if;
        end OUTPUT_MULTIPLE_COLUMNS;


--------------------------------------------
-- start of LIST
--------------------------------------------

    begin

        if TOKEN_DEFINITION.TOKEN_LENGTH >
           MACHINE_DEPENDENCIES.OUTPUT_PAGE_WIDTH then
            TERMINAL_INTERFACE.PUT_LINE
               (" The output page width is too narrow." &
                "  This operation is terminated.");
        else

--------------------------------------------
-- open the input file
--------------------------------------------

            begin
                TEXT_IO.OPEN
                   (FILE => INPUT,
                    MODE => TEXT_IO.IN_FILE,
                    NAME => INPUT_FILE (INPUT_FILE'RANGE),
                    FORM => "");
            exception
                when TEXT_IO.NAME_ERROR | TEXT_IO.STATUS_ERROR |
                     CONSTRAINT_ERROR =>
                    raise INVALID_INPUT_FILE;

                when others =>  TERMINAL_INTERFACE.PUT_LINE
                                   (" UNKNOWN ERROR in UTILITIES.LIST" &
                                    " on INPUT ");
            end;

--------------------------------------------
-- Create the output file
--------------------------------------------

            begin
                TEXT_IO.CREATE
                   (FILE => OUTPUT,
                    MODE => TEXT_IO.OUT_FILE,
                    NAME => OUTPUT_FILE (OUTPUT_FILE'RANGE),
                    FORM => "");
            exception
                when TEXT_IO.STATUS_ERROR | TEXT_IO.NAME_ERROR |
                     TEXT_IO.DEVICE_ERROR | CONSTRAINT_ERROR =>

                    raise INVALID_OUTPUT_FILE;

                when others =>  TERMINAL_INTERFACE.PUT_LINE
                                   (" UNKNOWN ERROR in UTILITIES.LIST" &
                                    " on OUTPUT ");
            end;

            if TOKEN_DEFINITION.TOKEN_LENGTH =
               MACHINE_DEPENDENCIES.OUTPUT_PAGE_WIDTH then
                loop
                    exit when TEXT_IO.END_OF_FILE (INPUT);
                    TEXT_IO.GET_LINE (INPUT, TOKEN.WORD, TOKEN.LENGTH);
                    TEXT_IO.PUT_LINE
                       (OUTPUT,
                        TOKEN.WORD (TOKEN.WORD'FIRST .. TOKEN.LENGTH));
                end loop;
            else
                OUTPUT_MULTIPLE_COLUMNS (INPUT, OUTPUT);
            end if;
            TEXT_IO.CLOSE (INPUT);
            TEXT_IO.CLOSE (OUTPUT);
        end if;
    end LIST;


--****************************************************************
--****************************************************************

--------------------------------------------------------------------------
-- Abstract   : This operation will merge two user dictionaries into
--            : one user dictionary.
--------------------------------------------------------------------------
-- Parameters : DICTIONARY_A : in out TEXT_IO.FILE_TYPE;
--            : DICTIONARY_B : in out TEXT_IO.FILE_TYPE;
--            : DICTIONARY_C : in out TEXT_IO.FILE_TYPE;
--            : These are the opened files.
--------------------------------------------------------------------------
-- Algorithm  : This process will merge DICTIONARY_A and DICTIONARY_B
-- into
--            : DICTIONARY_C.
--------------------------------------------------------------------------


    procedure MERGE (DICTIONARY_A,
                     DICTIONARY_B,
                     DICTIONARY_C : in out TEXT_IO.FILE_TYPE) is


        TOKEN : TOKEN_DEFINITION.TOKEN_TYPE;

        type TOKEN_COUNTER is record
             TOKEN : TOKEN_DEFINITION.TOKEN_TYPE;
             COUNTER : NATURAL := 0;
        end record;
        package SINGLY_LINKED_WORD_LIST is new SINGLY_LINKED_LIST
                   (TOKEN_COUNTER);

        use SINGLY_LINKED_WORD_LIST;

        TOKEN_COUNTER_LIST : SINGLY_LINKED_WORD_LIST.LIST_TYPE;

        function EQUALS (LEFT, RIGHT : TOKEN_DEFINITION.TOKEN_TYPE)
                          return BOOLEAN;

        package TOKEN_EQUALITY is new EQUALITY_OPERATOR
                   (TOKEN_DEFINITION.TOKEN_TYPE, EQUALS);

        function "=" (LEFT, RIGHT : TOKEN_DEFINITION.TOKEN_TYPE)
                       return BOOLEAN renames TOKEN_EQUALITY.EQUALS."=";

        function EQUALS (LEFT, RIGHT : TOKEN_DEFINITION.TOKEN_TYPE)
                          return BOOLEAN is
--------------------------------------------------------------------------
-- Abstract   : This function defines equality for tokens.
--------------------------------------------------------------------------
-- Parameters : Left & Right -- are tokens to be compared for equality.
--------------------------------------------------------------------------
        begin
            return LEFT.WORD (LEFT.WORD'FIRST .. LEFT.LENGTH) =
                   RIGHT.WORD (RIGHT.WORD'FIRST .. RIGHT.LENGTH);
        end EQUALS;



--**************************************************************************
--**************************************************************************



        function ">" (LEFT, RIGHT : TOKEN_DEFINITION.TOKEN_TYPE)
                       return BOOLEAN is
--------------------------------------------------------------------------
-- Abstract   : This function defines the "greater than" relation for
-- tokens.
--------------------------------------------------------------------------
-- Parameters : Left & Right -- are tokens to be compared
--------------------------------------------------------------------------
        begin
            return LEFT.WORD (LEFT.WORD'FIRST .. LEFT.LENGTH) >
                   RIGHT.WORD (RIGHT.WORD'FIRST .. RIGHT.LENGTH);
        end ">";


--*************************************************************************
--*************************************************************************




        procedure INITIALIZE is
--------------------------------------------------------------------------
-- Abstract   : This procedure empties the misspelled word list.
--------------------------------------------------------------------------
-- Algorithm  : Go to the head of the list and delete the head element
--              until the list is empty.
--------------------------------------------------------------------------
        begin
            FIRST (TOKEN_COUNTER_LIST);
            while not EMPTY (TOKEN_COUNTER_LIST) loop
                DELETE_ELEMENT (TOKEN_COUNTER_LIST);
            end loop;
        end INITIALIZE;

        procedure INSERT_WORD (TOKEN : TOKEN_DEFINITION.TOKEN_TYPE) is

--------------------------------------------------------------------------
-- Abstract   : This procedure inserts a token and the corrected token
--              into the linked list in ascending order if the token is
-- not
--              already in the list.
--------------------------------------------------------------------------
-- Parameters : Token - is the original word from the document.
--------------------------------------------------------------------------
-- Algorithm  : (a) Go to the head of the list.
--              (b) Traverse the list until the end of the list is
--                  encountered or a token is found in the list that has
--                  a value greater than or equal to the input
--                    parameter.
--              (c) select
--                    end-of-list =>
--                      insert input parameter at end of list
--                    token in list is greater than input parameter =>
--                      insert the input parameter in front of the
--                      element
--------------------------------------------------------------------------


        begin

            FIRST (TOKEN_COUNTER_LIST);

            while (not NULL_NODE (TOKEN_COUNTER_LIST)) and then
                  (TOKEN >
                   CURRENT_ELEMENT (TOKEN_COUNTER_LIST).TOKEN) loop
                NEXT (TOKEN_COUNTER_LIST);
            end loop;

            if NULL_NODE (TOKEN_COUNTER_LIST) then
                INSERT_AFTER
                   (LIST => TOKEN_COUNTER_LIST,
                    ELEMENT =>TOKEN_COUNTER'(TOKEN,0));

            elsif TOKEN =

                  CURRENT_ELEMENT (TOKEN_COUNTER_LIST).TOKEN then
                null;
            else
                INSERT_BEFORE
                   (LIST => TOKEN_COUNTER_LIST,
                    ELEMENT => TOKEN_COUNTER'(TOKEN,0));
            end if;

        end INSERT_WORD;


--**********************************************************************
--**********************************************************************


    begin
        INITIALIZE;

        loop
            begin
                TEXT_IO.GET_LINE
                   (DICTIONARY_A, TOKEN.WORD,TOKEN.LENGTH);

                if TOKEN.LENGTH > 0 then

                    INSERT_WORD (TOKEN);

                end if;

            exception
                when TEXT_IO.END_ERROR =>  exit;
            end;
        end loop;


        loop
            begin
                TEXT_IO.GET_LINE
                   (DICTIONARY_B, TOKEN.WORD,TOKEN.LENGTH);

                if TOKEN.LENGTH > 0 then

                    INSERT_WORD (TOKEN);

                end if;

            exception
                when TEXT_IO.END_ERROR =>  exit;
            end;
        end loop;

        if TEXT_IO.IS_OPEN (DICTIONARY_C) then
            TEXT_IO.RESET (DICTIONARY_C, TEXT_IO.OUT_FILE);
        end if;

        FIRST(TOKEN_COUNTER_LIST);

        while not NULL_NODE (TOKEN_COUNTER_LIST) loop

            TEXT_IO.PUT_LINE(DICTIONARY_C,
                CURRENT_ELEMENT(TOKEN_COUNTER_LIST).TOKEN.WORD
                   (CURRENT_ELEMENT(TOKEN_COUNTER_LIST).TOKEN.WORD'FIRST ..
                    CURRENT_ELEMENT(TOKEN_COUNTER_LIST).TOKEN.LENGTH));

            NEXT (TOKEN_COUNTER_LIST);

        end loop;

        TEXT_IO.CLOSE (DICTIONARY_C);

        if TEXT_IO.IS_OPEN (DICTIONARY_A) then
            TEXT_IO.CLOSE (DICTIONARY_A);
        end if;

        if TEXT_IO.IS_OPEN (DICTIONARY_B) then
            TEXT_IO.CLOSE (DICTIONARY_B);
        end if;
    end MERGE;

--****************************************************************
--****************************************************************

--------------------------------------------------------------------------
-- Abstract   : This operation will open a file.  This operation calls
--            : TEXT_IO.OPEN.
--------------------------------------------------------------------------
-- Parameters : FILE_NAME : STRING; is the name of the file to open.
--            : OPENED_FILE is the name of the file to be used for
--            : writing to reading from.
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------
    procedure OPEN (FILE_NAME   : STRING;
                    OPENED_FILE : in out TEXT_IO.FILE_TYPE) is


    begin
        TEXT_IO.OPEN
           (FILE => OPENED_FILE,
            MODE => TEXT_IO.IN_FILE,
            NAME => FILE_NAME (FILE_NAME'RANGE),
            FORM => "");
    end OPEN;


--------------------------------------------------------------------------
-- Abstract   : This operation will create a file.  This operaiton calls
--            : TEXT_IO.CREATE.
--------------------------------------------------------------------------
-- Parameters : FILE_NAME : STRING; is the name of the file to be
-- created.
--            : OPENED_FILE is the name of the file to be used for
--            : writing to reading from.
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

    procedure CREATE (FILE_NAME    : STRING;
                      CREATED_FILE : in out TEXT_IO.FILE_TYPE) is


    begin

        TEXT_IO.CREATE
           (FILE => CREATED_FILE,
            MODE => TEXT_IO.OUT_FILE,
            NAME => FILE_NAME (FILE_NAME'RANGE),
            FORM => "");
    end CREATE;


--****************************************************************
--****************************************************************


end UTILITIES;
::::::::::
CORR_SPEC.ADA
::::::::::
with TOKEN_DEFINITION,
     GET_USER_INFO;
package CORRECTOR is

   ABANDON_OPERATION : exception;
   BAD_WORD_FLAG     : BOOLEAN;


--------------------------------------------------------------------------
-- Abstract   : This operation will determine if a word has already been
--            : corrected.
--------------------------------------------------------------------------
-- Parameters : WORD : in TOKEN_DEFINITION.TOKEN_TYPE is the string being
--            : check for.
--            : LIST : in LIST_TYPE is the access value to the list
--            : of words which have already been corrected.
--------------------------------------------------------------------------
-- Algorithm  : (An optional paragraph describing any special algorithms
--               used by the package or routine.)
--------------------------------------------------------------------------


    function WAS_CORRECTED (TOKEN : TOKEN_DEFINITION.TOKEN_TYPE)
                 return BOOLEAN;


--**************************************************************************
--**************************************************************************



--------------------------------------------------------------------------
-- Abstract   : This operation will manage the requests to possible
--            : correct a misspelled word.
--------------------------------------------------------------------------
-- Parameters : WORD : in TOKEN_DEFINITION.TOKEN_TYPE is the word to be
--            : corrected.
--            : TO   : inTOKEN_DEFINITION.TOKEN_TYPE is what the word was
--            : corrected to.
--            : COMPLETED : out BOOLEAN indicates that the word has been
--            : corrected.
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------


    procedure CORRECT (USER_INFO : GET_USER_INFO.USER_INFO_TYPE;
                       WORD      : TOKEN_DEFINITION.TOKEN_TYPE);




    procedure INSERT_WORD(TOKEN,
                          CORRECTED_TOKEN : TOKEN_DEFINITION.TOKEN_TYPE);

    procedure INITIALIZE;


end CORRECTOR;
::::::::::
CORR_BODY.ADA
::::::::::
with TERMINAL_INTERFACE,
     MACHINE_DEPENDENCIES,
     EQUALITY_OPERATOR,
     TEXT_IO,
     RUN_TIME_STATISTICS,
     SINGLY_LINKED_LIST,
     DICTIONARY_MANAGER,
     DOCUMENT_HANDLER,
     HELP;
package body CORRECTOR is


    type TOKEN_COUNTER is
        record
            TOKEN           : TOKEN_DEFINITION.TOKEN_TYPE;
            CORRECTED_TOKEN : TOKEN_DEFINITION.TOKEN_TYPE;
        end record;

    package RTS renames RUN_TIME_STATISTICS;

    package SINGLY_LINKED_WORD_LIST is new SINGLY_LINKED_LIST
               (TOKEN_COUNTER);
    use SINGLY_LINKED_WORD_LIST;

    TOKEN_COUNTER_LIST : SINGLY_LINKED_WORD_LIST.LIST_TYPE;

    function "=" (LEFT,RIGHT : GET_USER_INFO.MODE_TYPE) return BOOLEAN
                        renames GET_USER_INFO."=";

    function EQUALS (LEFT, RIGHT : TOKEN_DEFINITION.TOKEN_TYPE)
                          return BOOLEAN;

    package TOKEN_EQUALITY is new EQUALITY_OPERATOR
                   (TOKEN_DEFINITION.TOKEN_TYPE, EQUALS);

    function "=" (LEFT, RIGHT : TOKEN_DEFINITION.TOKEN_TYPE)
                       return BOOLEAN renames TOKEN_EQUALITY.EQUALS."=";

    function EQUALS (LEFT, RIGHT : TOKEN_DEFINITION.TOKEN_TYPE)
                          return BOOLEAN is
--------------------------------------------------------------------------
-- Abstract   : This function defines equality for tokens.
--------------------------------------------------------------------------
-- Parameters : Left & Right -- are tokens to be compared for equality.
--------------------------------------------------------------------------
        begin
            return LEFT.WORD (LEFT.WORD'FIRST .. LEFT.LENGTH) =
                   RIGHT.WORD (RIGHT.WORD'FIRST .. RIGHT.LENGTH);
        end EQUALS;

        function ">" (LEFT, RIGHT : TOKEN_DEFINITION.TOKEN_TYPE)
                       return BOOLEAN is
--------------------------------------------------------------------------
-- Abstract   : This function defines the "greater than" relation for
-- tokens.
--------------------------------------------------------------------------
-- Parameters : Left & Right -- are tokens to be compared
--------------------------------------------------------------------------
        begin
            return LEFT.WORD (LEFT.WORD'FIRST .. LEFT.LENGTH) >
                   RIGHT.WORD (RIGHT.WORD'FIRST .. RIGHT.LENGTH);
        end ">";


--------------------------------------------------------------------------
-- Abstract   : This operation will determine if a word has already been
--            : corrected.
--------------------------------------------------------------------------
-- Parameters : WORD : in STRING is the string being check for.
--            : LIST : in LIST_PTR is the access value to the list
--            : of words which have already been corrected.
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------
    function WAS_CORRECTED (TOKEN : TOKEN_DEFINITION.TOKEN_TYPE)
                                             return BOOLEAN is
        CORRECTED : BOOLEAN := TRUE;

    begin

        FIRST (TOKEN_COUNTER_LIST);

        while (not NULL_NODE (TOKEN_COUNTER_LIST)) and then
              (TOKEN > CURRENT_ELEMENT (TOKEN_COUNTER_LIST).TOKEN) loop
            NEXT (TOKEN_COUNTER_LIST);
        end loop;

        if NULL_NODE (TOKEN_COUNTER_LIST) then
           CORRECTED := FALSE;

        elsif
           TOKEN = CURRENT_ELEMENT (TOKEN_COUNTER_LIST).TOKEN then
              begin

                   DOCUMENT_HANDLER.RESTORE_WORD(CURRENT_ELEMENT
                          (TOKEN_COUNTER_LIST).CORRECTED_TOKEN.WORD
                            (CURRENT_ELEMENT (TOKEN_COUNTER_LIST)
                                .CORRECTED_TOKEN.WORD'FIRST ..
                             CURRENT_ELEMENT(TOKEN_COUNTER_LIST)
                                      .CORRECTED_TOKEN.LENGTH));

                   IF TOKEN.LENGTH /= CURRENT_ELEMENT(TOKEN_COUNTER_LIST)
                                     .CORRECTED_TOKEN.LENGTH  then
                       RTS.INCREMENT_COUNTER(RTS.WORDS_CHANGING_LENGTH);
                   end if;

                   RTS.INCREMENT_COUNTER(RTS.CORRECTED_WORDS);

              exception when DOCUMENT_HANDLER.RESTORE_FAILED =>
                        RTS.INCREMENT_COUNTER(RTS.FAILED_RESTORES);

               end;
        else
            CORRECTED := FALSE;
        end if;
        return CORRECTED;
    end WAS_CORRECTED;

--**************************************************************************
--**************************************************************************



--*************************************************************************
--*************************************************************************


    procedure CORRECT (USER_INFO : GET_USER_INFO.USER_INFO_TYPE;
                       WORD      : TOKEN_DEFINITION.TOKEN_TYPE) is


        BLANK           : constant CHARACTER := ' ';
        CONTEXT         : DOCUMENT_HANDLER.CONTEXT;
        INDEX           : NATURAL;
        LENGTH          : NATURAL;
        LEVEL_3         : HELP.LEVEL_TYPE renames HELP.SPELL_HELP;

        USER_RESPONSE   : STRING
                            (1 .. MACHINE_DEPENDENCIES
                                   .FILE_LINE_LENGTH);
        ALL_OCCURRENCES : constant BOOLEAN := TRUE;
        DELETE          : constant BOOLEAN := FALSE;
        WORD_CHANGED    : BOOLEAN ;
        CHARACTERS_READ : NATURAL;
        type MENU_TYPE is array (POSITIVE range 1 .. 11)
                                 of STRING (1 .. 68);

        MENU : constant MENU_TYPE :=

    ("********************************************************************",
     "CORRECTOR                                                           ",
     "                                                                    ",
     "    Replace this word                Accept this word               ",
     "       R>eplace all Occurrences          A>ccept all Occurrences    ",
     "       O>nly this Occurrence             T>his Occurrence only      ",
     "                                                                    ",
     "    L>ookup Possible Corrections     ?>Help                         ",
     "    U>pdate user Dictionary          Q>uit                          ",
     "    D>elete word from Dictionary                                    ",
     "********************************************************************");

      procedure REPLACE(WORD : TOKEN_DEFINITION.TOKEN_TYPE;
                        ALL_OCCURRENCES :  BOOLEAN := FALSE) is

           CORRECTED_TOKEN : TOKEN_DEFINITION.TOKEN_TYPE;
           RESPONSE        : STRING (1 .. TOKEN_DEFINITION.TOKEN_LENGTH);
           LENGTH          : NATURAL;
           ABANDON         : exception;

      begin
          loop
             TERMINAL_INTERFACE.PUT
                  ("Replace <<" & WORD.WORD(WORD.WORD'FIRST ..
                                  WORD.LENGTH) & ">>  with =>");

             TERMINAL_INTERFACE.GET_LINE
                    (CORRECTED_TOKEN.WORD,CORRECTED_TOKEN.LENGTH);

             if CORRECTED_TOKEN.LENGTH < CORRECTED_TOKEN.WORD'FIRST then
                raise abandon;
             else
                TERMINAL_INTERFACE.PUT_LINE("Replacing '" &
                                        WORD.WORD(WORD.WORD'FIRST ..
                                                  WORD.LENGTH) &
                                           "' with '" &
                                        CORRECTED_TOKEN.WORD(
                                          CORRECTED_TOKEN.WORD'FIRST ..
                                          CORRECTED_TOKEN.LENGTH) &
                                        "' OK (Y/N)");
                TERMINAL_INTERFACE.GET_LINE(RESPONSE, LENGTH);
                if RESPONSE(RESPONSE'FIRST) = 'Y' or
                   RESPONSE(RESPONSE'FIRST) = 'y' then
                   exit;
                end if;
             end if;
          end loop;
          if ALL_OCCURRENCES then

                 INSERT_WORD(WORD,CORRECTED_TOKEN);
          end if;

          DOCUMENT_HANDLER.RESTORE_WORD(CORRECTED_TOKEN.WORD
                                (CORRECTED_TOKEN.WORD'FIRST ..
                                 CORRECTED_TOKEN.LENGTH));
          RTS.INCREMENT_COUNTER(RTS.CORRECTED_WORDS);

      exception
         when ABANDON => null;

         when DOCUMENT_HANDLER.RESTORE_FAILED =>
                TERMINAL_INTERFACE.PUT_LINE("Restore failed..." &
                        "operation ignored.");
                RTS.INCREMENT_COUNTER(RTS.FAILED_RESTORES);
                TERMINAL_INTERFACE.PUT_LINE("Hit return key to continue");
                TERMINAL_INTERFACE.GET_LINE(RESPONSE, LENGTH);
      end REPLACE;



      procedure MODIFY_DICT(USER_INFO : GET_USER_INFO.USER_INFO_TYPE;
                            TOKEN     : TOKEN_DEFINITION.TOKEN_TYPE;
                            UPDATE    : BOOLEAN := TRUE) is

            type CURRENT_DICT_TYPE is record
                                        NAME : STRING(1 .. MACHINE_DEPENDENCIES
                                                       .MAX_FILE_NAME_LENGTH);
                                        LENGTH : NATURAL;
                                        PTR    :DICTIONARY_MANAGER
                                                  .DICTIONARY_PTR;
                                      end record;

            CURRENT_DICT : array(POSITIVE range 1 .. GET_USER_INFO
                                                .NUMBER_OF_USER_DICTIONARIES)
                           of CURRENT_DICT_TYPE;

            USER_DICT : NATURAL := 0;
            INDEX     : NATURAL := 1;
            RESPONSE  : STRING(1 .. TOKEN_DEFINITION.TOKEN_LENGTH);
            NUMBER_OF_CHARACTERS : NATURAL ;
            WORD      : TOKEN_DEFINITION.TOKEN_TYPE := TOKEN;

            package INT_GET is new TEXT_IO.INTEGER_IO(NATURAL);

      begin

        if USER_INFO.USER_DICT.MODE = GET_USER_INFO.ENABLED then

           for I in 1 .. GET_USER_INFO.NUMBER_OF_USER_DICTIONARIES loop

                if USER_INFO.USER_DICT.NAMES(I).MODE =
                            GET_USER_INFO.ENABLED then

                   USER_DICT := USER_DICT + 1;

                   CURRENT_DICT(USER_DICT).NAME :=
                              USER_INFO.USER_DICT.NAMES(I).NAME;

                   CURRENT_DICT(USER_DICT).LENGTH :=
                              USER_INFO.USER_DICT.NAMES(I).LENGTH;

                   CURRENT_DICT(USER_DICT).PTR :=
                              USER_INFO.USER_DICT.NAMES(I).PTR;
                end if;
           end loop;

           for I in 1.. USER_DICT loop

                TERMINAL_INTERFACE.PUT(NATURAL'IMAGE(I));

                TERMINAL_INTERFACE.SET_COL(5);

                TERMINAL_INTERFACE.PUT_LINE
                            (CURRENT_DICT(I).NAME
                                  (CURRENT_DICT(I).NAME'FIRST ..
                                   CURRENT_DICT(I).LENGTH));
           end loop;

           TERMINAL_INTERFACE.PUT_LINE("Enter the number of the dictionary" &
                                       " to be modified");

           INT_GET.GET(USER_DICT,1);

           if UPDATE then
                begin

                     TERMINAL_INTERFACE.PUT_LINE
                         ("   Inserting <" & WORD.WORD(WORD.WORD'FIRST ..
                                                   WORD.LENGTH) &
                          "> into dictionary <" &
                          CURRENT_DICT(USER_DICT).NAME
                                (CURRENT_DICT(USER_DICT)
                                      .NAME'FIRST ..
                                 CURRENT_DICT(USER_DICT)
                                      .LENGTH) & "> OK (Y/N) ");

                      TERMINAL_INTERFACE.GET_LINE
                              (RESPONSE,NUMBER_OF_CHARACTERS);

                      if RESPONSE(RESPONSE'FIRST) = 'Y' or
                         RESPONSE(RESPONSE'FIRST) = 'y' then
                              DICTIONARY_MANAGER.INSERT_WORD
                                     ( WORD, CURRENT_DICT (USER_DICT).PTR);
                      end if;
                exception
                     when DICTIONARY_MANAGER.BAD_WORD =>
                             TERMINAL_INTERFACE.PUT_LINE
                                 (" Tried to insert an illegal word");
                             TERMINAL_INTERFACE.PUT_LINE
                                ("Hit return character to continue");
                             TERMINAL_INTERFACE.GET_LINE
                                (RESPONSE,LENGTH);

                     when DICTIONARY_MANAGER.DICTIONARY_ERROR =>
                             TERMINAL_INTERFACE.PUT_LINE("Inserting word" &
                                " into bad dictionary.");
                             TERMINAL_INTERFACE.PUT_LINE
                                ("Hit return key to continue");
                             TERMINAL_INTERFACE.GET_LINE
                                (RESPONSE,LENGTH);
                     when others => null;
               end;

          else
               begin
                     TERMINAL_INTERFACE.PUT_LINE
                         ("Enter the word to be deleted");

                     TERMINAL_INTERFACE.GET_LINE
                         (WORD.WORD,WORD.LENGTH);

                     TERMINAL_INTERFACE.PUT_LINE
                         ("Deleting <" & WORD.WORD(WORD.WORD'FIRST ..
                                                   WORD.LENGTH) &
                          "> from dictionary <" &
                          CURRENT_DICT(USER_DICT).NAME
                                (CURRENT_DICT(USER_DICT)
                                      .NAME'FIRST ..
                                 CURRENT_DICT(USER_DICT)
                                      .LENGTH) & "< OK (Y/N) ");

                      TERMINAL_INTERFACE.GET_LINE
                           (RESPONSE,NUMBER_OF_CHARACTERS);

                      if RESPONSE(RESPONSE'FIRST) = 'Y' or
                         RESPONSE(RESPONSE'FIRST) = 'y' then

                          DICTIONARY_MANAGER.DELETE_WORD
                                (WORD,CURRENT_DICT(USER_DICT).PTR);
                      end if;
               exception
                    when DICTIONARY_MANAGER.WORD_NOT_VALID |
                         DICTIONARY_MANAGER.BAD_WORD =>
                         TERMINAL_INTERFACE.PUT_LINE
                            ("Cannot delete word from dictionary.");
                         TERMINAL_INTERFACE.PUT_LINE
                            ("Hit return key to continue");
                         TERMINAL_INTERFACE.GET_LINE
                            (RESPONSE,LENGTH);

                    when DICTIONARY_MANAGER.DICTIONARY_ERROR =>
                                TERMINAL_INTERFACE.PUT_LINE
                                  ("Dictionary specified is invalid");
                                TERMINAL_INTERFACE.PUT_LINE
                                   ("Hit return key to continue");
                                TERMINAL_INTERFACE.GET_LINE
                                   (RESPONSE,LENGTH);

                    when others => null;


              end;
         end if;
         else
              TERMINAL_INTERFACE.PUT_LINE("There are no user dictionaries" &
                                        " currently enabled.");
              TERMINAL_INTERFACE.PUT_LINE("Hit return key to continue.");
              TERMINAL_INTERFACE.GET_LINE(RESPONSE,NUMBER_OF_CHARACTERS);
          end if;
     exception
              when others => null;
      end MODIFY_DICT;



----------------------------------------------------------------
--
-- Abstract     :  This procedure provides the user's option of
--              :  choosing a correction from a list provided by
--              :  the spelling corrector program.  A list is shown
--              :  and the user prompted for his/her choice.
--
----------------------------------------------------------------
--
-- Parameters   :  WORD_IN - A token record which will provide the
--              :  word to key the correction search.
--
----------------------------------------------------------------

  procedure LOOK_UP(WORD_IN : in TOKEN_DEFINITION.TOKEN_TYPE;
                    WORD_CHANGED : out BOOLEAN ) is


    GET_WORD      : TOKEN_DEFINITION.TOKEN_TYPE;
    NEW_WORD      : TOKEN_DEFINITION.TOKEN_TYPE;
    NUM_WORDS     : constant := 10;
    WORD_HOLDER   : array (1..NUM_WORDS) of TOKEN_DEFINITION.TOKEN_TYPE;
    WORD_BLANK    : constant STRING(1 .. TOKEN_DEFINITION.TOKEN_LENGTH)
                                := (others => ' ');
    CHOICE        : NATURAL;
    WORD_CT       : NATURAL;
    LINE_CT       : NATURAL;
    OFF_SET       : constant NATURAL := 5;
    RESPONSE      : STRING( 1 .. TOKEN_DEFINITION.TOKEN_LENGTH);

----------------------------------------------------------------
--
-- Abstract     :  A procedure containing a bubble sort algorithm
--              :  which sorts on the word field of the token
--              :  record.
--
----------------------------------------------------------------
--
-- Parameters   :  This procedure is internal to procedure LOOK_UP
--              :  and variables referenced within the procedure are
--              :  within the scope of procedure LOOK_UP.
--
----------------------------------------------------------------
--
-- Algorithm    :  The algorithm is a standard bubble sort.  The
--              :  fields used for sorting are sliced using the
--              :  shorter length, taking for granted that an equal
--              :  compare denotes the longer actual length as being
--              :  the greater value.
--
----------------------------------------------------------------

    procedure SORT is

    begin
      for OUTER in reverse 1..WORD_CT loop
        CHOICE := OUTER - 1;
        for INNER in 1..CHOICE loop
          if WORD_HOLDER(INNER).LENGTH <=
             WORD_HOLDER(INNER + 1).LENGTH
          then
            if WORD_HOLDER(INNER).WORD(1..WORD_HOLDER(INNER).LENGTH) >
               WORD_HOLDER(INNER + 1).WORD(1..WORD_HOLDER(INNER).LENGTH)
            then
              GET_WORD := WORD_HOLDER(INNER);
              WORD_HOLDER(INNER) := WORD_HOLDER(INNER + 1);
              WORD_HOLDER(INNER + 1) := GET_WORD;
            end if;
          else
            if WORD_HOLDER(INNER).WORD(1..WORD_HOLDER(INNER + 1).LENGTH) >=
               WORD_HOLDER(INNER + 1).WORD(1..WORD_HOLDER(INNER + 1).LENGTH)
            then
              GET_WORD := WORD_HOLDER(INNER);
              WORD_HOLDER(INNER) := WORD_HOLDER(INNER + 1);
              WORD_HOLDER(INNER + 1) := GET_WORD;
            end if;
          end if;
        end loop;
      end loop;
    end SORT;

  begin
    WORD_CHANGED := FALSE;
--Blank out the storage structure

    for INDEX in 1..NUM_WORDS loop
      WORD_HOLDER(INDEX).WORD := WORD_BLANK;
      WORD_HOLDER(INDEX).LENGTH := 1;
    end loop;

--Get the words from the dictionary

    begin
      DICTIONARY_MANAGER.INITIATOR(WORD_IN,NUM_WORDS);--initialize
      WORD_CT := 0;
      while DICTIONARY_MANAGER.MORE loop --while more words are desired
        WORD_CT := WORD_CT + 1;
        DICTIONARY_MANAGER.NEXT_WORD(WORD_HOLDER(WORD_CT));
      end loop;
    exception
      when DICTIONARY_MANAGER.NO_MORE_WORDS =>
                     WORD_HOLDER(WORD_CT).WORD := WORD_BLANK;
                     WORD_HOLDER(WORD_CT).LENGTH := 1;
                     WORD_CT := WORD_CT - 1;
    end;

-- If there were word returned then sort otherwise terminate

    if WORD_HOLDER(WORD_HOLDER'FIRST).LENGTH > 1 then

--Sort the words obtained in alphabetical order

    SORT;

--Print the words to the terminal

    if (WORD_CT rem 2) = 0
    then
      LINE_CT := WORD_CT/2;
    else
      LINE_CT := (WORD_CT + 1)/2;
    end if;
    for INDEX in 1..LINE_CT loop
      TERMINAL_INTERFACE.NEW_LINE;
      TERMINAL_INTERFACE.PUT(NATURAL'IMAGE((INDEX * 2) - 1));
      TERMINAL_INTERFACE.PUT(". ");
      TERMINAL_INTERFACE.PUT(WORD_HOLDER((INDEX * 2) - 1).WORD(1..
                            (WORD_HOLDER((INDEX * 2) - 1).LENGTH)));
      if WORD_HOLDER(INDEX * 2).LENGTH > 1
      then
        TERMINAL_INTERFACE.SET_COL
               (TEXT_IO.POSITIVE_COUNT(TOKEN_DEFINITION
                                    .TOKEN_LENGTH + OFF_SET));
        TERMINAL_INTERFACE.PUT(NATURAL'IMAGE(INDEX*2));
        TERMINAL_INTERFACE.PUT(". ");
        TERMINAL_INTERFACE.PUT_LINE(WORD_HOLDER(INDEX * 2).WORD(1..
                                 (WORD_HOLDER(INDEX * 2).LENGTH)));
      else
        TERMINAL_INTERFACE.NEW_LINE;
      end if;
    end loop;
    TERMINAL_INTERFACE.NEW_LINE;

--Prompt for user choice, reprompt if response improper

    loop
      TERMINAL_INTERFACE.PUT("Enter your choice, CR to quit: ");
      TERMINAL_INTERFACE.GET_LINE(GET_WORD.WORD,GET_WORD.LENGTH);
      exit when (GET_WORD.LENGTH = 0);
      if (GET_WORD.WORD(1) < '1') or (GET_WORD.WORD(1) > '9')
      then
        null;
      elsif
        (GET_WORD.LENGTH = 2) and (GET_WORD.WORD(2) /= '0')
        then
          null;
        elsif
          WORD_CT < (NATURAL'VALUE(GET_WORD.WORD(1..GET_WORD.LENGTH)))
          then
            null;
      else
        CHOICE := NATURAL'VALUE(GET_WORD.WORD(1..GET_WORD.LENGTH));
        TERMINAL_INTERFACE.NEW_LINE;
        exit;
      end if;
      TERMINAL_INTERFACE.NEW_LINE;
    end loop;

--Perform the desired action

    if GET_WORD.LENGTH > 0
    then
      begin
      case CHOICE is
        when 1 => DOCUMENT_HANDLER.RESTORE_WORD(WORD_HOLDER(1).WORD
                                    (1..WORD_HOLDER(1).LENGTH));

                  INSERT_WORD(WORD_IN,WORD_HOLDER(1));

                  WORD_CHANGED := TRUE;

                  IF WORD_IN.LENGTH /= WORD_HOLDER(1).LENGTH then
                      RTS.INCREMENT_COUNTER(RTS.WORDS_CHANGING_LENGTH);
                  end if;

                  RTS.INCREMENT_COUNTER(RTS.CORRECTED_WORDS);

        when 2 => DOCUMENT_HANDLER.RESTORE_WORD(WORD_HOLDER(2).WORD
                                    (1..WORD_HOLDER(2).LENGTH));

                  INSERT_WORD(WORD_IN,WORD_HOLDER(2));

                  WORD_CHANGED := TRUE;

                  IF WORD_IN.LENGTH /= WORD_HOLDER(2).LENGTH then
                      RTS.INCREMENT_COUNTER(RTS.WORDS_CHANGING_LENGTH);
                  end if;

                  RTS.INCREMENT_COUNTER(RTS.CORRECTED_WORDS);
        when 3 => DOCUMENT_HANDLER.RESTORE_WORD(WORD_HOLDER(3).WORD
                                    (1..WORD_HOLDER(3).LENGTH));

                  INSERT_WORD(WORD_IN,WORD_HOLDER(3));

                  WORD_CHANGED := TRUE;

                  IF WORD_IN.LENGTH /= WORD_HOLDER(3).LENGTH then
                      RTS.INCREMENT_COUNTER(RTS.WORDS_CHANGING_LENGTH);
                  end if;

                  RTS.INCREMENT_COUNTER(RTS.CORRECTED_WORDS);
        when 4 => DOCUMENT_HANDLER.RESTORE_WORD(WORD_HOLDER(4).WORD
                                    (1..WORD_HOLDER(4).LENGTH));

                  INSERT_WORD(WORD_IN,WORD_HOLDER(4));

                  WORD_CHANGED := TRUE;

                  IF WORD_IN.LENGTH /= WORD_HOLDER(4).LENGTH then
                      RTS.INCREMENT_COUNTER(RTS.WORDS_CHANGING_LENGTH);
                  end if;

                  RTS.INCREMENT_COUNTER(RTS.CORRECTED_WORDS);
        when 5 => DOCUMENT_HANDLER.RESTORE_WORD(WORD_HOLDER(5).WORD
                                    (1..WORD_HOLDER(5).LENGTH));

                  INSERT_WORD(WORD_IN,WORD_HOLDER(5));

                  WORD_CHANGED := TRUE;

                  IF WORD_IN.LENGTH /= WORD_HOLDER(5).LENGTH then
                      RTS.INCREMENT_COUNTER(RTS.WORDS_CHANGING_LENGTH);
                  end if;

                  RTS.INCREMENT_COUNTER(RTS.CORRECTED_WORDS);
        when 6 => DOCUMENT_HANDLER.RESTORE_WORD(WORD_HOLDER(6).WORD
                                    (1..WORD_HOLDER(6).LENGTH));

                  INSERT_WORD(WORD_IN,WORD_HOLDER(6));

                  WORD_CHANGED := TRUE;

                  IF WORD_IN.LENGTH /= WORD_HOLDER(6).LENGTH then
                      RTS.INCREMENT_COUNTER(RTS.WORDS_CHANGING_LENGTH);
                  end if;

                  RTS.INCREMENT_COUNTER(RTS.CORRECTED_WORDS);
        when 7 => DOCUMENT_HANDLER.RESTORE_WORD(WORD_HOLDER(7).WORD
                                    (1..WORD_HOLDER(7).LENGTH));

                  INSERT_WORD(WORD_IN,WORD_HOLDER(7));

                  WORD_CHANGED := TRUE;

                  IF WORD_IN.LENGTH /= WORD_HOLDER(7).LENGTH then
                      RTS.INCREMENT_COUNTER(RTS.WORDS_CHANGING_LENGTH);
                  end if;

                  RTS.INCREMENT_COUNTER(RTS.CORRECTED_WORDS);
        when 8 => DOCUMENT_HANDLER.RESTORE_WORD(WORD_HOLDER(8).WORD
                                    (1..WORD_HOLDER(8).LENGTH));

                  INSERT_WORD(WORD_IN,WORD_HOLDER(8));

                  WORD_CHANGED := TRUE;

                  IF WORD_IN.LENGTH /= WORD_HOLDER(8).LENGTH then
                      RTS.INCREMENT_COUNTER(RTS.WORDS_CHANGING_LENGTH);
                  end if;

                  RTS.INCREMENT_COUNTER(RTS.CORRECTED_WORDS);
        when 9 => DOCUMENT_HANDLER.RESTORE_WORD(WORD_HOLDER(9).WORD
                                    (1..WORD_HOLDER(9).LENGTH));

                  INSERT_WORD(WORD_IN,WORD_HOLDER(9));

                  WORD_CHANGED := TRUE;

                  IF WORD_IN.LENGTH /= WORD_HOLDER(9).LENGTH then
                      RTS.INCREMENT_COUNTER(RTS.WORDS_CHANGING_LENGTH);
                  end if;

                  RTS.INCREMENT_COUNTER(RTS.CORRECTED_WORDS);
        when 10 => DOCUMENT_HANDLER.RESTORE_WORD(WORD_HOLDER(10).WORD
                                    (1..WORD_HOLDER(10).LENGTH));

                   INSERT_WORD(WORD_IN,WORD_HOLDER(10));

                   WORD_CHANGED := TRUE;

                  IF WORD_IN.LENGTH /= WORD_HOLDER(10).LENGTH then
                      RTS.INCREMENT_COUNTER(RTS.WORDS_CHANGING_LENGTH);
                  end if;

                  RTS.INCREMENT_COUNTER(RTS.CORRECTED_WORDS);
        when others => TERMINAL_INTERFACE.PUT_LINE
                                         ("Error in selection, aborting.");
                       TERMINAL_INTERFACE.NEW_LINE;
                       WORD_CHANGED := FALSE;
      end case;
      exception
          when DOCUMENT_HANDLER.RESTORE_FAILED =>
                TERMINAL_INTERFACE.PUT_LINE("Restore failed .." &
                        "operation ignored.");
                RTS.INCREMENT_COUNTER(RTS.FAILED_RESTORES);
                TERMINAL_INTERFACE.PUT_LINE("Hit return key to continue");
                TERMINAL_INTERFACE.GET_LINE(RESPONSE,CHOICE);

     end;
    end if;
    else
        TERMINAL_INTERFACE.PUT_LINE("No similar words found");
        TERMINAL_INTERFACE.PUT_LINE("Hit return key to continue.");
        TERMINAL_INTERFACE.GET_LINE(RESPONSE, CHOICE);
    end if;
  end LOOK_UP;



    begin
        loop
            begin
              if not(BAD_WORD_FLAG)
              then
                TERMINAL_INTERFACE.NEW_PAGE;
                DOCUMENT_HANDLER.CONTEXT_OF_LAST_GET_WORD
                   (CONTEXT, INDEX, LENGTH);
                for I in DOCUMENT_HANDLER.CONTEXT'RANGE loop
                    TERMINAL_INTERFACE.PUT_LINE
                       (CONTEXT (I).LINE
                           (CONTEXT (I).LINE'FIRST ..
                            CONTEXT (I).LAST));
                    if I = POSITIVE(DOCUMENT_HANDLER.TARGET_LINE_IN_CONTEXT)
                        then
                           for J in 1 .. INDEX - 1 loop
                             TERMINAL_INTERFACE.PUT(" ");
                           end loop;
                           for J in 1 .. LENGTH loop
                             TERMINAL_INTERFACE.PUT("*");
                           end loop;
                   end if;

                    TERMINAL_INTERFACE.NEW_LINE;

                end loop;

                for I in MENU_TYPE'RANGE loop
                    TERMINAL_INTERFACE.PUT_LINE (MENU (I));
                end loop;

                TERMINAL_INTERFACE.GET_LINE
                   (USER_RESPONSE, CHARACTERS_READ);
              else
                USER_RESPONSE(USER_RESPONSE'FIRST) := 'T';
              end if;

                case USER_RESPONSE (USER_RESPONSE'FIRST) is

                    when 'R' | 'r' =>  REPLACE(WORD, ALL_OCCURRENCES);
                                       exit;

                    when 'O' | 'o' =>  REPLACE(WORD);
                                       exit;

                    when 'A' | 'a' =>  INSERT_WORD(WORD,WORD);
                                       exit;

                    when 'T' | 't' =>  BAD_WORD_FLAG := FALSE;
                                       exit;

                    when 'L' | 'l' =>  LOOK_UP(WORD,WORD_CHANGED);
                                       if WORD_CHANGED then
                                          exit;
                                       end if;

                    when 'U' | 'u' =>  MODIFY_DICT(USER_INFO,WORD);
                                       exit;

                    when 'Q' | 'q' =>  raise ABANDON_OPERATION;

                    when 'D' | 'd' =>  MODIFY_DICT(USER_INFO,WORD,DELETE);


                    when '?' =>  HELP.HELP_SCREEN (LEVEL_3);

                    when others =>
                        TERMINAL_INTERFACE.NEW_LINE;
                        TERMINAL_INTERFACE.PUT_LINE
                           ("<<" &
                            USER_RESPONSE
                               (USER_RESPONSE'FIRST ..
                                CHARACTERS_READ) & ">>");
                        TERMINAL_INTERFACE.PUT_LINE
                           (" is not one of your possible choices. ");
                        TERMINAL_INTERFACE.PUT_LINE
                           (" Reenter your choice.");
                        delay (DURATION (2.0));
                end case;
            exception
                when ABANDON_OPERATION => raise;
                when others =>  null;
            end;
            USER_RESPONSE(USER_RESPONSE'FIRST) := BLANK;
        end loop;
        USER_RESPONSE(USER_RESPONSE'FIRST) := BLANK;
    end CORRECT;


--*************************************************************************
--*************************************************************************




    procedure INITIALIZE is
--------------------------------------------------------------------------
-- Abstract   : This procedure empties the misspelled word list.
--------------------------------------------------------------------------
-- Algorithm  : Go to the head of the list and delete the head element
--              until the list is empty.
--------------------------------------------------------------------------
    begin
        FIRST (TOKEN_COUNTER_LIST);
        while not EMPTY (TOKEN_COUNTER_LIST) loop
            DELETE_ELEMENT (TOKEN_COUNTER_LIST);
        end loop;
    end INITIALIZE;

    procedure INSERT_WORD
                 (TOKEN, CORRECTED_TOKEN : TOKEN_DEFINITION
                                            .TOKEN_TYPE) is
--------------------------------------------------------------------------
-- Abstract   : This procedure inserts a token and the corrected token
--              into the linked list in ascending order if the token is not
--              already in the list.
--------------------------------------------------------------------------
-- Parameters : Token - is the original word from the document.
--            : CORRECTED TOKEN is what the user wish the word to be
--------------------------------------------------------------------------
-- Algorithm  : (a) Go to the head of the list.
--              (b) Traverse the list until the end of the list is
--                  encountered or a token is found in the list that has
--                  a value greater than or equal to the input
--                    parameter.
--              (c) select
--                    end-of-list =>
--                      insert input parameter at end of list
--                    token in list is greater than input parameter =>
--                      insert the input parameter in front of the
--                      element
--------------------------------------------------------------------------


    begin

        FIRST (TOKEN_COUNTER_LIST);

        while (not NULL_NODE (TOKEN_COUNTER_LIST)) and then
              (TOKEN > CURRENT_ELEMENT (TOKEN_COUNTER_LIST).TOKEN) loop
            NEXT (TOKEN_COUNTER_LIST);
        end loop;

        if NULL_NODE (TOKEN_COUNTER_LIST) then
            INSERT_AFTER (LIST    => TOKEN_COUNTER_LIST,
                          ELEMENT =>
                            TOKEN_COUNTER'(TOKEN, CORRECTED_TOKEN));
        elsif TOKEN = CURRENT_ELEMENT (TOKEN_COUNTER_LIST).TOKEN then
            null;
        else
            INSERT_BEFORE (LIST    => TOKEN_COUNTER_LIST,
                           ELEMENT =>
                             TOKEN_COUNTER'(TOKEN, CORRECTED_TOKEN));
        end if;

    end INSERT_WORD;


--**********************************************************************
--**********************************************************************

begin

    INITIALIZE;

end CORRECTOR;
::::::::::
PROCESS_SPEC.ADA
::::::::::
with MISSPELLED_WORD_LIST,
     MACHINE_DEPENDENCIES,
     DICTIONARY_MANAGER,
     DOCUMENT_HANDLER,
     GET_USER_INFO,
     TOKEN_DEFINITION;
package PROCESS_PACKAGE is

    UPPER_CASE_A : constant CHARACTER := 'A';
    LOWER_CASE_A : constant CHARACTER := 'a';
    UPPER_CASE_I : constant CHARACTER := 'I';
    LOWER_CASE_I : constant CHARACTER := 'i';

    procedure BATCH_PROCESS (USER_INFO : in out GET_USER_INFO.USER_INFO_TYPE);

    procedure INTERACTIVE_PROCESS (USER_INFO : in out GET_USER_INFO
                                                          .USER_INFO_TYPE);

end PROCESS_PACKAGE;
::::::::::
PROCESS_BODY.ADA
::::::::::

with TERMINAL_INTERFACE,
     TEXT_IO,
     RUN_TIME_STATISTICS,
     CORRECTOR;

package body PROCESS_PACKAGE is

    NO_MORE_WORDS                   : exception renames
                                         DOCUMENT_HANDLER.NO_MORE_WORDS;
    ABANDON                         : exception;
    INVALID_USER_DICTIONARY_REQUEST : exception;

    function "=" (LEFT,RIGHT : GET_USER_INFO.MODE_TYPE) return BOOLEAN
                   renames GET_USER_INFO."=";

    package RTS renames RUN_TIME_STATISTICS;



--****************************************************************
--****************************************************************


--------------------------------------------------------------------------
-- Abstract   : This operation will sumerize the run time statics
--            : collected during the operation of the tool.
--            : The statistics collected are :
--            :          number of words corrected
--            :          number of suspect words
--            :          number of restore request which failed
--            :          number of words which were replaced with
--            :              of a different length.
--------------------------------------------------------------------------
-- Parameters : FILE is the suspect word list provided by the user.
--            : If the corrector were activated then the file is invalid.
--            : The statistics will be reported to the screen.
--------------------------------------------------------------------------
-- Algorithm  :
--            :
--------------------------------------------------------------------------

procedure WRAPUP (USER_INFO : GET_USER_INFO .USER_INFO_TYPE) is

begin
    if USER_INFO.MODE = GET_USER_INFO.DISABLED then
        TEXT_IO.PUT_LINE ("There were " &
           NATURAL'IMAGE(RUN_TIME_STATISTICS.COUNT
                   (RUN_TIME_STATISTICS.SUSPECT_WORDS)) &
           " suspect words detected.");
    else

       TERMINAL_INTERFACE.NEW_PAGE;

       TERMINAL_INTERFACE.NEW_LINE (2);

       TERMINAL_INTERFACE.PUT_LINE("There were " &
                NATURAL'IMAGE(RUN_TIME_STATISTICS.COUNT
                      (RUN_TIME_STATISTICS.CORRECTED_WORDS)) &
                " words corrected.");

       TERMINAL_INTERFACE.NEW_LINE (2);

       TERMINAL_INTERFACE.PUT_LINE("There were " &
                NATURAL'IMAGE (RUN_TIME_STATISTICS.COUNT
                      (RUN_TIME_STATISTICS.SUSPECT_WORDS)) &
                " suspect words detected.");

       TERMINAL_INTERFACE.NEW_LINE (2);

       TERMINAL_INTERFACE.PUT_LINE("There were " &
                NATURAL'IMAGE(RUN_TIME_STATISTICS.COUNT
                      (RUN_TIME_STATISTICS.FAILED_RESTORES)) &
                " request(s) to restore words which were unsuccessful");

       if RUN_TIME_STATISTICS.COUNT
                (RUN_TIME_STATISTICS.WORDS_CHANGING_LENGTH) > 0 then

          TERMINAL_INTERFACE.NEW_LINE (2);

          TERMINAL_INTERFACE.PUT_LINE("There were " &
                NATURAL'IMAGE (RUN_TIME_STATISTICS.COUNT
                      (RUN_TIME_STATISTICS.WORDS_CHANGING_LENGTH)) &
                " words which changed length.");

          TERMINAL_INTERFACE.PUT_LINE ("Reformat.");

       end if;
    end if;
end WRAPUP;

--****************************************************************
--****************************************************************


--------------------------------------------------------------------------
-- Abstract   : This operation will initialize the processing
--            : information contained in the USER_INFO record.
--            : All dictionaries will be ENABLED or DISABLED as
--            : necessary.  All options will be identified and
--            : the appropriate steps taken to to insure proper
--            : processing.
--------------------------------------------------------------------------
-- Parameters : USER_INFO : GET_USER_INFO.USER_INFO_TYPE
--            : This parameter is a record containg all of the
--            : processing supplied by the user.
--            : FILE the file of the suspect word list.
--------------------------------------------------------------------------
-- Algorithm  :
--            :
--------------------------------------------------------------------------
procedure INITIALIZE (USER_INFO : in out GET_USER_INFO.USER_INFO_TYPE;
                      FILE      : in out TEXT_IO.FILE_TYPE) is

    DICTIONARY_PTR : DICTIONARY_MANAGER.DICTIONARY_PTR;
    RESPONSE       : STRING (GET_USER_INFO.NAME_RANGE);
    LENGTH         : NATURAL;

begin
    begin

        if TEXT_IO.IS_OPEN( FILE) then
               TEXT_IO.CLOSE(FILE);
        end if;

        TEXT_IO.CREATE (FILE, TEXT_IO.OUT_FILE,
                        USER_INFO.WORD_LIST.NAME
                           (USER_INFO.WORD_LIST.NAME'FIRST ..
                            USER_INFO.WORD_LIST.LENGTH));

    exception
        when others =>
            TEXT_IO.PUT_LINE
               (TEXT_IO.STANDARD_OUTPUT,
                "Error in filename <<" &
                USER_INFO.WORD_LIST.NAME
                   (USER_INFO.WORD_LIST.NAME'FIRST ..
                    USER_INFO.WORD_LIST.LENGTH) & ">>");

            TEXT_IO.PUT_LINE
               (TEXT_IO.STANDARD_OUTPUT,
                "The file is invalid.  " &
                "This operation is terminated.");

            raise ABANDON;
    end;


    begin

         DOCUMENT_HANDLER.OPEN_SOURCE
            (USER_INFO.DOCUMENT.NAME
                (USER_INFO.DOCUMENT.NAME'FIRST ..
                 USER_INFO.DOCUMENT.LENGTH));
    exception
        when others =>
              if TEXT_IO.IS_OPEN(FILE) then
                 TEXT_IO.PUT_LINE(FILE,
                        "Document <<" & USER_INFO.DOCUMENT.NAME
                         (USER_INFO.DOCUMENT.NAME'FIRST ..
                          USER_INFO.DOCUMENT.LENGTH) &
                        ">> is invalid.");

                       TEXT_IO.PUT_LINE(FILE,
                        "This operation is terminated.");

                  TEXT_IO.CLOSE(FILE);

                 if USER_INFO.MODE = GET_USER_INFO.ENABLED then
                    TERMINAL_INTERFACE.PUT_LINE
                        ("Document <<" & USER_INFO.DOCUMENT.NAME
                          (USER_INFO.DOCUMENT.NAME'FIRST ..
                           USER_INFO.DOCUMENT.LENGTH) &
                         ">> is invalid.");
                    TERMINAL_INTERFACE.PUT_LINE
                        ("This operation is terminated.");
                    TERMINAL_INTERFACE.PUT_LINE
                        ("Hit return key to acknowledge.");
                    TERMINAL_INTERFACE.GET_LINE(RESPONSE,LENGTH);
                 end if;

                 raise ABANDON;



              else
                  TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,

                        "Document <<" & USER_INFO.DOCUMENT.NAME
                         (USER_INFO.DOCUMENT.NAME'FIRST ..
                          USER_INFO.DOCUMENT.LENGTH) &
                        ">> is invalid.");

                       TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                           "This operations is terminated.");

                       if USER_INFO.MODE = GET_USER_INFO.ENABLED then

                       TERMINAL_INTERFACE.PUT_LINE
                          ("Hit any key to acknowledge");

                       TERMINAL_INTERFACE.GET_LINE(RESPONSE,LENGTH);
                       end if;
                       raise ABANDON;
              end if;
    end;

    if USER_INFO.MODE = GET_USER_INFO.ENABLED then
        begin

             DOCUMENT_HANDLER.OPEN_DESTINATION
                (USER_INFO.CORRECTED_DOC.NAME
                    (USER_INFO.CORRECTED_DOC.NAME'FIRST ..
                     USER_INFO.CORRECTED_DOC.LENGTH));
        exception
            when others => DOCUMENT_HANDLER.CLOSE_SOURCE_AND_DESTINATION;

                           if TEXT_IO.IS_OPEN(FILE) then
                                TEXT_IO.CLOSE(FILE);
                           end if;

                           TERMINAL_INTERFACE.PUT_LINE
                              ("Document <<" &
                                USER_INFO.CORRECTED_DOC.NAME
                                    (USER_INFO.CORRECTED_DOC.NAME'FIRST ..
                                     USER_INFO.CORRECTED_DOC.LENGTH) &
                                ">> is invalid." );

                           TERMINAL_INTERFACE.PUT_LINE
                             ("This operation is terminated.");

                           TERMINAL_INTERFACE.PUT_LINE
                                ("Hit any key to acknowledge");

                          TERMINAL_INTERFACE.GET_LINE(RESPONSE,LENGTH);

                           raise ABANDON;
        end;

    end if;

    if USER_INFO.MASTER then

         begin

            DICTIONARY_MANAGER.ENABLE_DICTIONARY
               (DICTIONARY_MANAGER.GET_MASTER_DICTIONARY);
         exception
            when DICTIONARY_MANAGER.DICTIONARY_ERROR =>

               begin

                    DICTIONARY_MANAGER.CREATE_DICTIONARY
                       (DICTIONARY_MANAGER.MASTER, DICTIONARY_PTR,
                        MACHINE_DEPENDENCIES.MASTER_DICTIONARY);

                exception
                    when STORAGE_ERROR =>
                         TEXT_IO.PUT_LINE (TEXT_IO.STANDARD_OUTPUT,
                                           "Error in master creation");

                       TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                              "Hit any key to acknowledge");
                       TEXT_IO.GET_LINE(RESPONSE,LENGTH);
                    when others => null;
                end;

            when others =>  TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                                "unknown exception on Master Enable");
                       TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                              "Hit any key to acknowledge");
                       TEXT_IO.GET_LINE(RESPONSE,LENGTH);
         end;


    else
        begin

             DICTIONARY_MANAGER.DISABLE
                (DICTIONARY_MANAGER.GET_MASTER_DICTIONARY);
        exception
             when others  => null;
        end;
    end if;

    if USER_INFO.ACRONYM then

         begin

            DICTIONARY_MANAGER.ENABLE_DICTIONARY
               (DICTIONARY_MANAGER.GET_ACRONYM_DICTIONARY);

         exception
            when DICTIONARY_MANAGER.DICTIONARY_ERROR =>
                 begin

                      DICTIONARY_MANAGER.CREATE_DICTIONARY
                         (DICTIONARY_MANAGER.ACRONYM, DICTIONARY_PTR,
                          MACHINE_DEPENDENCIES.ACRONYM_DICTIONARY);

                 exception
                      when STORAGE_ERROR =>

                       TEXT_IO.PUT_LINE (TEXT_IO.STANDARD_OUTPUT,
                                           "Error in acronym creation");
                       TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                              "Hit any key to acknowledge");
                       TEXT_IO.GET_LINE(RESPONSE,LENGTH);

                      when others => null;

                 end;
            when others => TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                              "Unknown error on Acronym Enable");
         end;
    else
        begin

           DICTIONARY_MANAGER.DISABLE
              (DICTIONARY_MANAGER.GET_ACRONYM_DICTIONARY);
        exception
           when others => null;

        end;
    end if;

------------------------------------------------------------------
--    process the user dictionaries
------------------------------------------------------------------

    for I in 1 .. GET_USER_INFO.NUMBER_OF_USER_DICTIONARIES loop

        if USER_INFO.USER_DICT.NAMES (I).MODE =
           GET_USER_INFO.ENABLED then

              begin
                   DICTIONARY_MANAGER.ENABLE_DICTIONARY
                      (USER_INFO.USER_DICT.NAMES (I).PTR);
              exception
                   when DICTIONARY_MANAGER.DICTIONARY_ERROR =>
                       begin
                            DICTIONARY_MANAGER.CREATE_DICTIONARY
                                (DICTIONARY_MANAGER.USER,
                                 USER_INFO.USER_DICT.NAMES(I).PTR,
                                 USER_INFO.USER_DICT.NAMES (I).NAME
                                 (USER_INFO.USER_DICT.NAMES (I).NAME'FIRST ..
                                 USER_INFO.USER_DICT.NAMES (I).LENGTH));

                       exception
                            when STORAGE_ERROR =>
                                 TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                                       "Cannot create user dictionary." &
                                       "  Not enough storage.");

                                 TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                                        "Hit any key to acknowledge");
                                 TEXT_IO.GET_LINE(RESPONSE,LENGTH);
                            when others =>
                                  USER_INFO.USER_DICT.NAMES(I).MODE :=
                                        GET_USER_INFO.DISABLED;
                       end;
                   when others =>  raise INVALID_USER_DICTIONARY_REQUEST;
              end;

        else
              begin

                    DICTIONARY_MANAGER.DISABLE
                       (USER_INFO.USER_DICT.NAMES (I).PTR);
              exception
                    when DICTIONARY_MANAGER.DICTIONARY_ERROR =>
                       null;
              end;

        end if;
    end loop;

end INITIALIZE;


--****************************************************************
--****************************************************************


----------------------------------------------------------
-- Abstract   : This operation will change the case of the first letter
--            : of a word.
--------------------------------------------------------------------------
-- Parameters : WORD : TOKEN_DEFINITION.TOKEN_TYPE;
--            : This parameter is a record containg a word (string) and
--            : the length of a word.
--------------------------------------------------------------------------
-- Algorithm  : If the first character is in the uppercase range change
--            : it to lower case and return the word.  Otherwise change
--            : it to uppercase.  All of this only applies to word whose
--            : first character is in the alpha range.
--------------------------------------------------------------------------

    procedure CHANGE_CASE (WORD : in out TOKEN_DEFINITION.TOKEN_TYPE) is

        subtype UPPER_CASE_RANGE is INTEGER
                                      range CHARACTER'POS ('A') ..
                                            CHARACTER'POS ('Z');

        CASE_CONSTANT : constant NATURAL :=
                        CHARACTER'POS ('a') - CHARACTER'POS ('A');

    begin
        if CHARACTER'POS (WORD.WORD (WORD.WORD'FIRST)) in
           UPPER_CASE_RANGE'FIRST .. UPPER_CASE_RANGE'LAST or else
           CHARACTER'POS (WORD.WORD (WORD.WORD'FIRST)) -
           CASE_CONSTANT in
           UPPER_CASE_RANGE'FIRST .. UPPER_CASE_RANGE'LAST then

            if CHARACTER'POS (WORD.WORD (WORD.WORD'FIRST)) in
               UPPER_CASE_RANGE'FIRST .. UPPER_CASE_RANGE'LAST then
                WORD.WORD (WORD.WORD'FIRST) :=
                  CHARACTER'VAL
                    (CHARACTER'POS (WORD.WORD (WORD.WORD'FIRST)) +
                     CASE_CONSTANT);
            else
                WORD.WORD (WORD.WORD'FIRST) :=
                  CHARACTER'VAL
                    (CHARACTER'POS (WORD.WORD (WORD.WORD'FIRST)) -
                     CASE_CONSTANT);
            end if;
        end if;
    end CHANGE_CASE;


--****************************************************************
--****************************************************************


--------------------------------------------------------------------------
-- Abstract   : This operation will check variant forms of a word for
--            : presence in a dictionary.  If the word ends in a
--            : period or an apostrophe then strip it off.  Search the
--            : dictionaries for the changed word.  If found then
--            : all is well.  If not found then change the case
--            : and search again.  If still not found then report
--            : that the word is most likely spelled incorrectly.
--------------------------------------------------------------------------
-- Parameters : WORD : TOKEN_DEFINITION.TOKEN_TYPE;
--            : is a record containg the fields WORD : which
--            : a string and LENGTH which indicates the number
--            : of characters in the WORD.
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

    function FOUND_OTHER_FORM (WORD : TOKEN_DEFINITION.TOKEN_TYPE)
                                return BOOLEAN is

        TOKEN          : TOKEN_DEFINITION.TOKEN_TYPE := WORD;
        PERIOD         : constant CHARACTER := '.';
        APOSTROPHE     : constant CHARACTER := ''';
        DICTIONARY_PTR : DICTIONARY_MANAGER.DICTIONARY_PTR;
        FOUND          : BOOLEAN := FALSE;

    begin

        if TOKEN.WORD (TOKEN.LENGTH) = PERIOD or else
           TOKEN.WORD (TOKEN.LENGTH) = APOSTROPHE then

            TOKEN.WORD (TOKEN.WORD'FIRST .. TOKEN.LENGTH - 1) :=
              TOKEN.WORD (TOKEN.WORD'FIRST .. TOKEN.LENGTH - 1);

            TOKEN.LENGTH := TOKEN.LENGTH - 1;

            if TOKEN.LENGTH >= 1 then
                DICTIONARY_MANAGER.TOKEN_IS_FOUND
                   (DICTIONARY_PTR, TOKEN, FOUND);
                if FOUND then
                    null;
                else
                    CHANGE_CASE (TOKEN);
                    DICTIONARY_MANAGER.TOKEN_IS_FOUND
                       (DICTIONARY_PTR, TOKEN, FOUND);
                end if;
            end if;
        else
            CHANGE_CASE (TOKEN);
            DICTIONARY_MANAGER.TOKEN_IS_FOUND
               (DICTIONARY_PTR, TOKEN, FOUND);
        end if;
        return FOUND;
    end FOUND_OTHER_FORM;



--****************************************************************
--****************************************************************


--------------------------------------------------------------------------
-- Abstract   : This operation will check a document for misspelled
--            : words.
--            : If any are found it will cause them to be list to a file
--            : designated by the user.
--------------------------------------------------------------------------
-- Parameters : USER_INFO : GET_USER_INFO.USER_INFO_TYPE;
--            : This record contains the processing information supplied
--            : by the user.
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------


    procedure BATCH_PROCESS
                 (USER_INFO : in out GET_USER_INFO.USER_INFO_TYPE) is

        IN_BOUNDS      : BOOLEAN;
        FOUND          : BOOLEAN;
        WORD           : TOKEN_DEFINITION.TOKEN_TYPE;
        DICTIONARY_PTR : DICTIONARY_MANAGER.DICTIONARY_PTR;
        FILE           : TEXT_IO.FILE_TYPE;


    begin

        INITIALIZE(USER_INFO,FILE);

        RTS.INITIALIZE_COUNTERS;

        MISSPELLED_WORD_LIST.INITIALIZE;

        loop
          begin
            DOCUMENT_HANDLER.GET_WORD (WORD, IN_BOUNDS);

            if IN_BOUNDS and then WORD.LENGTH > 1 then

                DICTIONARY_MANAGER.TOKEN_IS_FOUND
                   (DICTIONARY_PTR, WORD, FOUND);

                if FOUND then
                    null;
                elsif FOUND_OTHER_FORM (WORD) then
                    null;
                else
                    RTS.INCREMENT_COUNTER(RTS.SUSPECT_WORDS);
                    MISSPELLED_WORD_LIST.ADD_TOKEN (WORD);
                end if;
            elsif WORD.LENGTH < 2 and
                  (WORD.WORD (WORD.LENGTH) = UPPER_CASE_A or
                   WORD.WORD (WORD.LENGTH) = UPPER_CASE_I or
                   WORD.WORD (WORD.LENGTH) = LOWER_CASE_A or
                   WORD.WORD (WORD.LENGTH) = LOWER_CASE_I) then
                null;
            else
                RTS.INCREMENT_COUNTER(RTS.SUSPECT_WORDS);
                MISSPELLED_WORD_LIST.ADD_TOKEN (WORD);
            end if;
          exception
            when DICTIONARY_MANAGER.BAD_WORD =>
                 RTS.INCREMENT_COUNTER(RTS.SUSPECT_WORDS);
                 MISSPELLED_WORD_LIST.ADD_TOKEN(WORD);
          end;
        end loop;
    exception
        when NO_MORE_WORDS =>
            DOCUMENT_HANDLER.CLOSE_SOURCE_AND_DESTINATION;
            WRAPUP(USER_INFO);
            MISSPELLED_WORD_LIST.PRINT (FILE);
            TEXT_IO.CLOSE (FILE);

            for I in 1 .. GET_USER_INFO.NUMBER_OF_USER_DICTIONARIES loop
                begin
                     DICTIONARY_MANAGER.DELETE_DICTIONARY
                        (USER_INFO.USER_DICT.NAMES(I).PTR);
                exception
                     when DICTIONARY_MANAGER.DICTIONARY_ERROR => null;
                end;
            end loop;

        when ABANDON => if TEXT_IO.IS_OPEN(FILE) then
                                TEXT_IO.CLOSE (FILE);
                        else null;
                        end if;
        when others =>  if TEXT_IO.IS_OPEN(FILE) then
                                TEXT_IO.PUT_LINE
                                (FILE, "Unrecoverable error in processing");
                                TEXT_IO.PUT_LINE(FILE,
                                "Check your processing options and retry.");
                                TEXT_IO.CLOSE (FILE);
                        else
                           TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                            "Unrecoverable error in processing.");
                          TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                            "Check your processing options and retry.");
                        end if;

    end BATCH_PROCESS;


--****************************************************************
--****************************************************************

--------------------------------------------------------------------------
-- Abstract   : This operation will check a document for misspelled
--            : words.  If any are found it will cause the context of
--            : the word to be displayed to the user.  It will then be
--            : up to the user to determine what the next step will be.
--            : The user will be given a number choices from which to
--            : choose.
--------------------------------------------------------------------------
-- Parameters : USER_INFO : GET_USER_INFO.USER_INFO_TYPE;
--            : This record contains the processing information supplied
--            : by the user.
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------


procedure INTERACTIVE_PROCESS
             (USER_INFO : in out GET_USER_INFO.USER_INFO_TYPE) is

    IN_BOUNDS      : BOOLEAN;
    FOUND          : BOOLEAN;
    COMPLETED      : BOOLEAN;
    WORD           : TOKEN_DEFINITION.TOKEN_TYPE;
    DICTIONARY_PTR : DICTIONARY_MANAGER.DICTIONARY_PTR;
    FILE           : TEXT_IO.FILE_TYPE;
    RESPONSE       : STRING (1 .. TOKEN_DEFINITION.TOKEN_LENGTH);
    LENGTH         : NATURAL;


begin
    INITIALIZE (USER_INFO, FILE);

    RTS.INITIALIZE_COUNTERS;

    CORRECTOR.INITIALIZE;

    MISSPELLED_WORD_LIST.INITIALIZE;

    loop
      begin
        DOCUMENT_HANDLER.GET_WORD (WORD, IN_BOUNDS);

        if IN_BOUNDS and then WORD.LENGTH > 1 then

            DICTIONARY_MANAGER.TOKEN_IS_FOUND
                 (DICTIONARY_PTR, WORD, FOUND);

            if FOUND then
                null;
            elsif FOUND_OTHER_FORM (WORD) then
                null;
            else

                if CORRECTOR.WAS_CORRECTED (WORD) then
                    null;
                else
                    MISSPELLED_WORD_LIST.ADD_TOKEN (WORD);
                    RTS.INCREMENT_COUNTER(RTS.SUSPECT_WORDS);
                    CORRECTOR.CORRECT (USER_INFO,WORD);

                end if;
            end if;
        elsif WORD.LENGTH < 2 and
              (WORD.WORD (WORD.LENGTH) = UPPER_CASE_A or
               WORD.WORD (WORD.LENGTH) = UPPER_CASE_I or
               WORD.WORD (WORD.LENGTH) = LOWER_CASE_A or
               WORD.WORD (WORD.LENGTH) = LOWER_CASE_I) then
            null;
        else

           if CORRECTOR.WAS_CORRECTED (WORD) then
                null;
           else
                RTS.INCREMENT_COUNTER(RTS.SUSPECT_WORDS);
                MISSPELLED_WORD_LIST.ADD_TOKEN (WORD);
                CORRECTOR.CORRECT (USER_INFO,WORD);
           end if;

        end if;
      exception
        when DICTIONARY_MANAGER.BAD_WORD =>
                  RTS.INCREMENT_COUNTER(RTS.SUSPECT_WORDS);
                  MISSPELLED_WORD_LIST.ADD_TOKEN(WORD);
                  CORRECTOR.BAD_WORD_FLAG := TRUE;
                  CORRECTOR.CORRECT(USER_INFO,WORD);
      end;
    end loop;
exception
    when NO_MORE_WORDS =>
        DOCUMENT_HANDLER.CLOSE_SOURCE_AND_DESTINATION;

        for I in 1 .. GET_USER_INFO.NUMBER_OF_USER_DICTIONARIES loop
                begin
                      if DICTIONARY_MANAGER.ALTER
                         (USER_INFO.USER_DICT.NAMES(I).PTR)
                        then DICTIONARY_MANAGER.LIST_DICTIONARY
                             (USER_INFO.USER_DICT.NAMES(I).PTR,
                              USER_INFO.USER_DICT.NAMES(I)
                                .NAME(USER_INFO.USER_DICT
                                      .NAMES(I).NAME'FIRST ..
                                      USER_INFO.USER_DICT.NAMES(I).LENGTH));
                      end if;

                     DICTIONARY_MANAGER.DELETE_DICTIONARY
                                 (USER_INFO.USER_DICT.NAMES(I).PTR);
                exception
                     when others => null;
                end;
        end loop;

        MISSPELLED_WORD_LIST.PRINT(FILE);
        TEXT_IO.CLOSE(FILE);
        WRAPUP(USER_INFO);
        TERMINAL_INTERFACE.PUT_LINE("Hit return key to continue");
        TERMINAL_INTERFACE.GET_LINE(RESPONSE,LENGTH);

    when ABANDON =>  if TEXT_IO.IS_OPEN(FILE) then
                        TEXT_IO.CLOSE(FILE);
                     end if;

    when CORRECTOR.ABANDON_OPERATION =>
                DOCUMENT_HANDLER.CLOSE_SOURCE_AND_DESTINATION;

                if TEXT_IO.IS_OPEN(FILE) then
                    TEXT_IO.CLOSE(FILE);
                end if;

                for I in 1 .. GET_USER_INFO.NUMBER_OF_USER_DICTIONARIES loop
                    begin
                        DICTIONARY_MANAGER.DELETE_DICTIONARY
                                (USER_INFO.USER_DICT.NAMES(I).PTR);
                    exception
                        when others => null;

                    end;
                end loop;

    when INVALID_USER_DICTIONARY_REQUEST =>
             TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                           "Invalid user dictionary request");
             TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                              "Hit return key to acknowledge");
             TEXT_IO.GET_LINE(RESPONSE,LENGTH);
    when others =>
        TEXT_IO.PUT_LINE (TEXT_IO.STANDARD_OUTPUT,
                           "Unrecoverable error in processing");

        TEXT_IO.PUT_LINE (TEXT_IO.STANDARD_OUTPUT,
                          "Check your processing options and retry.");

        TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                              "Hit return key to acknowledge");
        TEXT_IO.GET_LINE(RESPONSE,LENGTH);

        begin
             DOCUMENT_HANDLER.CLOSE_SOURCE_AND_DESTINATION;
        exception
             when others => null;
        end ;

end INTERACTIVE_PROCESS;

--****************************************************************
--****************************************************************

end PROCESS_PACKAGE;
::::::::::
CLINE_HANDLER.ADA
::::::::::
--
-- COMMAND_LINE_HANDLER by Richard Conn, TI Ada Technology Branch
-- 27 Feb 85
--
package COMMAND_LINE_HANDLER is
--------------------------------------------------------------------------
-- Abstract   : This package contains routines which return words
--               from the command line tail (parameters following
--               the command line verb).  It expects a file to have
--               been created externally which contains these words,
--               one word per line.
--------------------------------------------------------------------------

    NO_COMMAND_LINE_FILE : exception;
    NO_MORE_WORDS        : exception;


    procedure NEXT_WORD (WORD : out STRING; LENGTH : out NATURAL);
--------------------------------------------------------------------------
-- Abstract   : NEXT_WORD returns the next word from the command
--               line tail.  If there are no more words, NO_MORE_WORDS
--               is raised.  If there is no command line file,
--               NO_COMMAND_LINE_FILE is raised.
--------------------------------------------------------------------------
-- Parameters : WORD           - string containing the next word
--              LENGTH         - number of chars in next word
--------------------------------------------------------------------------


    procedure RESET;
--------------------------------------------------------------------------
-- Abstract   : If the file containing the command line's words
--               is open, this file is closed.  The net effect is
--               that the next invocation of NEXT_WORD will return
--               the first word of the command line tail.
--------------------------------------------------------------------------

end COMMAND_LINE_HANDLER;


with TEXT_IO;
package body COMMAND_LINE_HANDLER is

    COMMAND_LINE_FILE_NAME : constant STRING := "COMMAND_LINE.TXT";
    COMMAND_FILE           : TEXT_IO.FILE_TYPE;


    procedure RESET is
    begin
        if TEXT_IO.IS_OPEN (COMMAND_FILE) then
            TEXT_IO.CLOSE (COMMAND_FILE);
        end if;
    end RESET;

    procedure NEXT_WORD (WORD : out STRING; LENGTH : out NATURAL) is
    begin
        if not TEXT_IO.IS_OPEN (COMMAND_FILE) then
            begin
                TEXT_IO.OPEN (COMMAND_FILE, TEXT_IO.IN_FILE,
                              COMMAND_LINE_FILE_NAME);
            exception
                when others =>
                    raise NO_COMMAND_LINE_FILE;
            end;
        end if;
        TEXT_IO.GET_LINE (COMMAND_FILE, WORD, LENGTH);
    exception
        when NO_COMMAND_LINE_FILE =>
            raise;
        when others =>
            raise NO_MORE_WORDS;
    end NEXT_WORD;

end COMMAND_LINE_HANDLER;
::::::::::
CLINE_IFACE.ADA
::::::::::
package COMMAND_LINE_INTERFACE is
--------------------------------------------------------------------------
--
-- Abstract   : This package returns the names of files as they were entered
--               on the command line.  The SPELL command line is of the
--               following general syntax:
--
--                      spell document_file word_list master_dict acronym_dict
--                              user1_dict user2_dict ... user6_dict
--
--               This is the fixed-parameter form.  Named parameters are also
--               permitted of the general form:
--
--                      spell name=file
--
--               where valid 'name' values are:
--
--                      F - for document file
--                      W - for word list
--                      M - for master dictionary
--                      A - for acronym dictionary
--                      Un - for user dictionary, where n is 1-6
--
--               The command line may include fixed parameters followed
--               by named parameters, but no fixed parameters may follow
--               any named parameters.  Examples:
--
--                      SPELL myfile.txt u1=mywords.dct m=technical
--                              document is MYFILE.TXT, master dictionary
--                              is TECHNICAL, user dictionary 1 is MYWORDS.DCT
--
--                      SPELL myfile.txt words technical tac mywords.dct
--                              document is MYFILE.TXT, word list is WORDS,
--                              master dictionary is TECHNICAL, acronym
--                              dictionary is TAC, and user 1 dictionary is
--                              MYWORDS.DCT
--
--                      SPELL myfile.txt u6=hiswords.txt
--                              document is MYFILE.TXT and user 6 dictionary
--                              is HISWORDS.TXT
--
--------------------------------------------------------------------------

    MIX_ERROR              : exception;
    NAME_ERROR             : exception;
    USER_DICTIONARY_NUMBER : exception;
--------------------------------------------------------------------------
-- MIX_ERROR is raised during the command line parse when a fixed
--  parameter is encountered after a named parameter was processed;
--  for example,
--      SPELL myfile.txt m=master mywords
--  will raise a MIX_ERROR when MYWORDS is processed because the
--  named parameter "M=MASTER" was previously encountered.  Once named
--  parameters are encountered, fixed parameter positioning is lost.
--
-- NAME_ERROR is raised during the command line parse when a named
--  parameter is invalid, like "X=MYFILE", where X is not one of the
--  legal names F, W, M, A, or Un.
--
-- USER_DICTIONARY_NUMBER is raised during the command line parse when
--  the number following the U in a named parameter association is not
--  in the range 1..6.  For example, "SPELL myfile.txt u7=user" will
--  raise this exception because U7 is not in the range U1..U6.
-- USER_DICTIONARY_NUMBER is also raised when the procedure USER_DICTIONARY
--  is called with a KEY whose value is not in the range 1..6.
--
-- Any exception raised during the command line parse results in the
--  error word being set, and the procedure BAD_WORD will return the
--  error word so the point at which the parse failed can be examined.
--
--------------------------------------------------------------------------


    procedure FILE_NAME (FILE : out STRING; LAST : out NATURAL);
--------------------------------------------------------------------------
-- Abstract   : Return the name of the document file, if any.  If LAST=0,
--               no document file was specified.
--------------------------------------------------------------------------
-- Parameters : FILE           - string containing document file name
--              LAST           - number of characters in file name
--------------------------------------------------------------------------


    procedure WORD_LIST (FILE : out STRING; LAST : out NATURAL);
--------------------------------------------------------------------------
-- Abstract   : Return the name of the word list file, if any.
--------------------------------------------------------------------------
-- Parameters : As above.
--------------------------------------------------------------------------


    procedure MASTER_DICTIONARY (FILE : out STRING; LAST : out NATURAL);
--------------------------------------------------------------------------
-- Abstract   : Return the name of the master dictionary file, if any.
--------------------------------------------------------------------------
-- Parameters : As above.
--------------------------------------------------------------------------


    procedure ACRONYM_DICTIONARY (FILE : out STRING; LAST : out NATURAL);
--------------------------------------------------------------------------
-- Abstract   : Return the name of the acronym dictionary file, if any.
--------------------------------------------------------------------------
-- Parameters : As above.
--------------------------------------------------------------------------


    procedure USER_DICTIONARY (KEY  : NATURAL;
                               FILE : out STRING;
                               LAST : out NATURAL);
--------------------------------------------------------------------------
-- Abstract   : Return the name of user dictionary N, where 1 <= N <= 6.
--               The exception USER_DICTIONARY_NUMBER will be raised if
--               the passed parameter (KEY) is not in the range 1..6.
--------------------------------------------------------------------------
-- Parameters : KEY            - Number of user dictionary desired (1..6)
--              FILE           - string containing the name of the user dict
--              LAST           - number of characters in the name of dict
--------------------------------------------------------------------------


    procedure BAD_WORD (WORD : out STRING; LAST : out NATURAL);
--------------------------------------------------------------------------
-- Abstract   : If the parse of the command line parameters fails for some
--               reason, such as an invalid named association being
--               employed (like X=file, where X isn't one of F,W,M,A,Un),
--               this routine will return the word at which the parse
--               failed.  This error word is set by any of the exceptions
--               (above) being raised.
--------------------------------------------------------------------------
-- Parameters : WORD           - string containing the word in error
--              LAST           - number of characters in word
--------------------------------------------------------------------------

end COMMAND_LINE_INTERFACE;


with COMMAND_LINE_HANDLER,
     CHARACTER_SET;
package body COMMAND_LINE_INTERFACE is

    subtype NAME_STRING is STRING (1 .. 80);
    type NAME_RECORD is
        record
            NAME : NAME_STRING;
            LAST : NATURAL;
        end record;

    NAMES_SIZE          : constant := 10; -- 4 entries and 6 user dicts
    NAMES               : array (1 .. NAMES_SIZE) of NAME_RECORD;
    FILE_IDX            : constant := 1;
    WORD_IDX            : constant := 2;
    MDICT_IDX           : constant := 3;
    ADICT_IDX           : constant := 4;
    UDICT_IDX           : constant := 5;

    ERROR_WORD          : NAME_RECORD;
    ARE_NAMES_EXTRACTED : BOOLEAN := FALSE;

    procedure INITIALIZE_NAMES is
    begin
        for I in 1 .. NAMES_SIZE loop
            NAMES (I).NAME := (others => ' ');
            NAMES (I).LAST := 0;
        end loop;
    end INITIALIZE_NAMES;

    function IS_NAMED_ASSOCIATION (WORD : STRING) return BOOLEAN is
    begin
        for I in WORD'FIRST .. WORD'LAST loop
            if WORD (I) = '=' then
                return TRUE;
            end if;
        end loop;
        return FALSE;
    end IS_NAMED_ASSOCIATION;

    procedure PROCESS_ASSOCIATION (STR : STRING) is
        WORD    : NAME_STRING;
        LAST    : NATURAL;
        IDX     : NATURAL;
        IN_NAME : BOOLEAN := FALSE;
    begin
        case CHARACTER_SET.TO_UPPER (STR (1)) is
            when 'F' =>  IDX := 1;
            when 'W' =>  IDX := 2;
            when 'M' =>  IDX := 3;
            when 'A' =>  IDX := 4;
            when 'U' =>
                case STR (2) is
                    when '1' =>  IDX := 5;
                    when '2' =>  IDX := 6;
                    when '3' =>  IDX := 7;
                    when '4' =>  IDX := 8;
                    when '5' =>  IDX := 9;
                    when '6' =>  IDX := 10;
                    when others =>
                        raise USER_DICTIONARY_NUMBER;
                end case;
            when others =>
                ERROR_WORD.NAME (1 .. STR'LENGTH) := STR;
                ERROR_WORD.LAST := STR'LENGTH;
                raise NAME_ERROR;
        end case;
        LAST := 0;
        for I in STR'FIRST .. STR'LAST loop
            if IN_NAME then
                LAST := LAST + 1;
                WORD (LAST) := STR (I);
            else
                if STR (I) = '=' then
                    IN_NAME := TRUE;
                end if;
            end if;
        end loop;
        NAMES (IDX).NAME (1 .. LAST) := WORD (1 .. LAST);
        NAMES (IDX).LAST := LAST;
    end PROCESS_ASSOCIATION;

    procedure EXTRACT_NAMES is
        WORD        : NAME_STRING;
        WORD_LENGTH : NATURAL;
        INDEX       : NATURAL := 0;
        NAME_FLAG   : BOOLEAN := FALSE;
    begin
        if not ARE_NAMES_EXTRACTED then
            INITIALIZE_NAMES;
            ARE_NAMES_EXTRACTED := TRUE;
            loop
                COMMAND_LINE_HANDLER.NEXT_WORD (WORD, WORD_LENGTH);
                if IS_NAMED_ASSOCIATION (WORD (1 .. WORD_LENGTH)) then
                    PROCESS_ASSOCIATION (WORD (1 .. WORD_LENGTH));
                    NAME_FLAG := TRUE;
                else
                    if not NAME_FLAG then
                        INDEX := INDEX + 1;
                        NAMES (INDEX).NAME := WORD;
                        NAMES (INDEX).LAST := WORD_LENGTH;
                    else
                        ERROR_WORD.NAME := WORD;
                        ERROR_WORD.LAST := WORD_LENGTH;
                        raise MIX_ERROR;
                    end if;
                end if;
            end loop;
        end if;
    exception
        when MIX_ERROR =>
            raise;
        when others =>
            null;
    end EXTRACT_NAMES;

    procedure BAD_WORD (WORD : out STRING; LAST : out NATURAL) is
        COUNT : NATURAL;
    begin
        COUNT := 0;
        for I in WORD'FIRST .. WORD'LAST loop
            COUNT := COUNT + 1;
            WORD (I) := ERROR_WORD.NAME (COUNT);
            exit when COUNT = ERROR_WORD.LAST;
        end loop;
        LAST := COUNT;
    end BAD_WORD;

    procedure GET_WORD (IDX  : NATURAL;
                        WORD : out STRING;
                        LAST : out NATURAL) is
        COUNT : NATURAL := 0;
    begin
        if NAMES (IDX).LAST /= 0 then
            for I in WORD'FIRST .. WORD'LAST loop
                COUNT := COUNT + 1;
                WORD (I) := NAMES (IDX).NAME (COUNT);
                exit when COUNT = NAMES (IDX).LAST;
            end loop;
        end if;
        LAST := COUNT;
    end GET_WORD;

    procedure FILE_NAME (FILE : out STRING; LAST : out NATURAL) is
    begin
        EXTRACT_NAMES;
        GET_WORD (FILE_IDX, FILE, LAST);
    end FILE_NAME;

    procedure WORD_LIST (FILE : out STRING; LAST : out NATURAL) is
    begin
        EXTRACT_NAMES;
        GET_WORD (WORD_IDX, FILE, LAST);
    end WORD_LIST;

    procedure MASTER_DICTIONARY (FILE : out STRING; LAST : out NATURAL) is
    begin
        EXTRACT_NAMES;
        GET_WORD (MDICT_IDX, FILE, LAST);
    end MASTER_DICTIONARY;

    procedure ACRONYM_DICTIONARY (FILE : out STRING; LAST : out NATURAL) is
    begin
        EXTRACT_NAMES;
        GET_WORD (ADICT_IDX, FILE, LAST);
    end ACRONYM_DICTIONARY;

    procedure USER_DICTIONARY (KEY  : NATURAL;
                               FILE : out STRING;
                               LAST : out NATURAL) is
    begin
        if KEY in 1 .. 6 then
            EXTRACT_NAMES;
            GET_WORD (UDICT_IDX + KEY - 1, FILE, LAST);
        else
            raise USER_DICTIONARY_NUMBER;
        end if;
    end USER_DICTIONARY;

end COMMAND_LINE_INTERFACE;
::::::::::
SPELLER.ADA
::::::::::
--------------------------------------------------------------------------
-- Abstract   : This is the main procedure for the SPELLING CORRECTOR.
--            : From here the user can interactively execute this tool,
--            : or execute in batch.
--------------------------------------------------------------------------
-- Parameters :
--
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

with COMMAND_LINE_INTERFACE,
     MACHINE_DEPENDENCIES,
     TERMINAL_INTERFACE,
     TOKEN_DEFINITION,
     PROCESS_PACKAGE,
     GET_USER_INFO,
     UTILITIES,
     TEXT_IO,
     HELP;

procedure SPELLER is

    TIME_PERIOD          : constant DURATION := 2.0;

    LEVEL_1              : HELP.LEVEL_TYPE renames HELP.HELP_HELP;

    PROCESSING_COMMAND_LINE : BOOLEAN := FALSE;

    NUMBER_OF_CHARACTERS : NATURAL;

    USER_RESPONSE        : STRING
                             (1 .. MACHINE_DEPENDENCIES
                                    .MAX_FILE_NAME_LENGTH);

    USER_INFO            : GET_USER_INFO.USER_INFO_TYPE;

    ABANDON                     : exception;

    INVALID_EXECUTION_ATTEMPTED : exception;

    function "=" (LEFT,RIGHT : GET_USER_INFO.MODE_TYPE) return BOOLEAN
                   renames GET_USER_INFO."=";

--***************************************************************
--***************************************************************


--------------------------------------------------------------------------
-- Abstract   : This operation will display the title page to the terminal
--            : device.
--------------------------------------------------------------------------
-- Parameters :
--
--------------------------------------------------------------------------
-- Algorithm  :
--            :
--------------------------------------------------------------------------

    procedure DISPLAY_TITLE_PAGE is

    TITLE_PAGE_LINE_1 : constant STRING :=
    ("                    SPELLER - Interactive Spelling Checker ");

    TITLE_PAGE_LINE_2 : constant STRING :=
    ("                                Version 0.001");

    TO_SCREEN_CENTER  : constant TERMINAL_INTERFACE.COUNT_TYPE := 11;

begin
    TERMINAL_INTERFACE.NEW_PAGE;

    TERMINAL_INTERFACE.PUT_LINE (TITLE_PAGE_LINE_1);
    TERMINAL_INTERFACE.PUT_LINE (TITLE_PAGE_LINE_2);

    TERMINAL_INTERFACE.NEW_LINE (TO_SCREEN_CENTER);

    delay (TIME_PERIOD);

end DISPLAY_TITLE_PAGE;

--****************************************************************
--****************************************************************

--------------------------------------------------------------------------
-- Abstract   : After the title page is displayed, the command choices
--            : the user may make are displayed.
--------------------------------------------------------------------------
-- Parameters :
--
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

procedure DISPLAY_COMMAND_CHOICES is

    SPELLER_COMMAND_LINE_1 : constant STRING :=
                   ("  [?] Help                  [L] List dictionary");

    SPELLER_COMMAND_LINE_2 : constant STRING :=
                   ("  [M] Merge dictionaries    [S] Spell check a document");

    SPELLER_COMMAND_LINE_3 : constant STRING := ("  [Q] Quit  ");

begin

-----------------------------------------------------------------
-- This will require the entire page, therefore it is necessary
-- to remove the old menu from the screen prior to displaying
-- the title page.
-----------------------------------------------------------------
    TERMINAL_INTERFACE.NEW_PAGE;

-----------------------------------------------------------------
-- Now that the title page is displayed, begin to display
-- the command choices.
-----------------------------------------------------------------

    TERMINAL_INTERFACE.PUT_LINE (SPELLER_COMMAND_LINE_1);

    TERMINAL_INTERFACE.PUT_LINE (SPELLER_COMMAND_LINE_2);

    TERMINAL_INTERFACE.PUT_LINE (SPELLER_COMMAND_LINE_3);

    TERMINAL_INTERFACE.NEW_LINE;

-----------------------------------------------------------------
-- Ouptut the user prompt
-----------------------------------------------------------------

    TERMINAL_INTERFACE.PUT_LINE ("Enter your request <<cr>>");

end DISPLAY_COMMAND_CHOICES;

--****************************************************************
--****************************************************************

--------------------------------------------------------------------------
-- Abstract   : This operation will begin the spelling correction
-- process.
--            :  The steps taken are;
--            :      1. Read the default processing options from
--            :         SPELL_DATA.INI file.
--            :      2. If the read was successful then print out the
--            :         the processing options until the user is
--            :         confirms these options.
--            :      3. Once confirmed, write out the processing options
--            :         to the SPELL_DATA.INI file.
--            :      4. If the user chose the BATCH processing option
--            :         execute the BATCH_PROCESS operation.
--            :         Otherwise, execute the INTERACTIVE_PROCESS
--            :         operation.
--------------------------------------------------------------------------
-- Parameters :
--
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

procedure BEGIN_DOCUMENT_CHECK is

    USER_RESPONSE : STRING (1 .. MACHINE_DEPENDENCIES.FILE_LINE_LENGTH);

    LENGTH        : NATURAL;

    USER_INFO     : GET_USER_INFO.USER_INFO_TYPE;

    SUCCESSFUL    : BOOLEAN := FALSE;

    procedure DISPLAY (USER_INFO : GET_USER_INFO.USER_INFO_TYPE) is

    begin
        TERMINAL_INTERFACE.NEW_PAGE;

        TERMINAL_INTERFACE.PUT_LINE
           ("The processing options are as follows:");

        if USER_INFO.DOCUMENT.LENGTH <
           USER_INFO.DOCUMENT.NAME'FIRST  then
           TERMINAL_INTERFACE.PUT_LINE
              ("The document being checked is <<>>");
        else
            TERMINAL_INTERFACE.PUT_LINE
               ("The document being checked is <<" &
                USER_INFO.DOCUMENT.NAME
                    (USER_INFO.DOCUMENT.NAME'FIRST ..
                     USER_INFO.DOCUMENT.LENGTH) & ">>");
        end if;

        if USER_INFO.CORRECTED_DOC.LENGTH <
           USER_INFO.CORRECTED_DOC.NAME'FIRST  then
           TERMINAL_INTERFACE.PUT_LINE
                ("The corrected document will be <<>>");
        else
           TERMINAL_INTERFACE.PUT_LINE
                ("The corrected document will be <<" &
                  USER_INFO.CORRECTED_DOC.NAME
                  (USER_INFO.CORRECTED_DOC.NAME'FIRST ..
                  USER_INFO.CORRECTED_DOC.LENGTH) & ">>");

        end if;

        if USER_INFO.WORD_LIST.LENGTH >= USER_INFO.WORD_LIST.NAME'FIRST
             then TERMINAL_INTERFACE.PUT_LINE
               ("The suspect word list is <<" &
                USER_INFO.WORD_LIST.NAME
                    (USER_INFO.WORD_LIST.NAME'FIRST ..
                     USER_INFO.WORD_LIST.LENGTH) & ">>");
        else
           TERMINAL_INTERFACE.PUT_LINE
               ("The suspect word list is <<>>");
        end if;

        if USER_INFO.MODE = GET_USER_INFO.DISABLED then
            TERMINAL_INTERFACE.PUT_LINE
               ("The CORRECTOR is <<Disabled>>");
        else
            TERMINAL_INTERFACE.PUT_LINE
               ("The CORRECTOR is <<Enabled>>");
        end if;

        if USER_INFO.MASTER then
            TERMINAL_INTERFACE.PUT_LINE ("The MASTER is <<Enabled>>");
        else
            TERMINAL_INTERFACE.PUT_LINE ("The MASTER is <<Disabled>>");
        end if;

        if USER_INFO.ACRONYM then
            TERMINAL_INTERFACE.PUT_LINE ("The ACRONYM is <<Enabled>>");
        else
            TERMINAL_INTERFACE.PUT_LINE ("The ACRONYM is <<Disabled>>");
        end if;

        if USER_INFO.USER_DICT.MODE = GET_USER_INFO.ENABLED then
            TERMINAL_INTERFACE.PUT_LINE
               ("The user dictionaries enabled are as follows:");

            for I in 1 .. GET_USER_INFO.NUMBER_OF_USER_DICTIONARIES loop

                if USER_INFO.USER_DICT.NAMES(I).MODE =
                        GET_USER_INFO.ENABLED  then

                    TERMINAL_INTERFACE.PUT_LINE
                        (USER_INFO.USER_DICT.NAMES (I).NAME
                         (USER_INFO.USER_DICT.NAMES (I).NAME'FIRST ..
                           USER_INFO.USER_DICT.NAMES (I).LENGTH));
                end if;
            end loop;
        else
            TERMINAL_INTERFACE.PUT_LINE
               ("No user dictionaries are enabled");
        end if;
    end DISPLAY;

begin


    TERMINAL_INTERFACE.NEW_PAGE;

    GET_USER_INFO.GET_INFO (USER_INFO, SUCCESSFUL);

    if SUCCESSFUL then
        null;
    else
        GET_USER_INFO.COLLECT_USER_INFO (USER_INFO);
    end if;

    loop
        DISPLAY (USER_INFO);
        TERMINAL_INTERFACE.PUT_LINE
           ("Type <space> to change options, " &
            "or <cr> to confirm options and continue");
        TERMINAL_INTERFACE.GET_LINE (USER_RESPONSE, LENGTH);
        exit when LENGTH = 0;
        GET_USER_INFO.COLLECT_USER_INFO(USER_INFO);
    end loop;

    GET_USER_INFO.SAVE_INFO (USER_INFO);

    if USER_INFO.MODE = GET_USER_INFO.DISABLED then
        PROCESS_PACKAGE.BATCH_PROCESS (USER_INFO);

    else
        PROCESS_PACKAGE.INTERACTIVE_PROCESS (USER_INFO);
    end if;

end BEGIN_DOCUMENT_CHECK;

--****************************************************************
--****************************************************************

--------------------------------------------------------------------------
-- Abstract   : This operation will merge two user dictionaries
--
--------------------------------------------------------------------------
-- Parameters :
--
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

procedure BEGIN_MERGE_OPERATIONS is

    HELP_LEVEL          : HELP.LEVEL_TYPE renames HELP.MERGE_HELP;

    INPUT_FILE_A        : TEXT_IO.FILE_TYPE;

    INPUT_FILE_B        : TEXT_IO.FILE_TYPE;

    OUTPUT_FILE         : TEXT_IO.FILE_TYPE;

    HELP_COMMAND        : constant STRING :=
                          ("For Help in this operation hit '?' ");

    DICTIONARY_PROMPT_1 : constant STRING :=
                          ("Enter first dictionary name to be merged =>");

    DICTIONARY_PROMPT_2 : constant STRING :=
                          ("Enter second dictionary name to be merged  =>");

    DICTIONARY_PROMPT_3 : constant STRING :=
                          ("Enter output dictionary name =>");

    DICTIONARY_NAME_1   : STRING
                            (1 .. MACHINE_DEPENDENCIES
                                   .MAX_FILE_NAME_LENGTH);

    DICTIONARY_NAME_2   : STRING
                            (1 .. MACHINE_DEPENDENCIES
                                   .MAX_FILE_NAME_LENGTH);

    DICTIONARY_NAME_3   : STRING
                            (1 .. MACHINE_DEPENDENCIES
                                   .MAX_FILE_NAME_LENGTH);

    NAME_LENGTH         : NATURAL := 0;

    ERROR_OCCURRENCE    : NATURAL range 0 .. 2 := 0;

    NEEDS_HELP      : exception renames UTILITIES.NEEDS_HELP;

    TERMINATE_ERROR : exception;

    ABANDON         : exception renames UTILITIES.ABANDON;

-------------------------------------------------
-- This local procedure will get a dictionary name
-- from a user.  If the dictionary name is unique
-- and if it is a valid dictionary file name, this
-- procedure will also open the file.  The arguments
-- pased are the dictionary name which is returned
-- with a valid name and a file which is returned as
-- a valid opened file.
-------------------------------------------------

    procedure GET_AND_OPEN_DICTIONARY
                 (DICTIONARY_NAME : in out STRING;
                  PROMPT          : STRING;
                  FILE            : in out TEXT_IO.FILE_TYPE) is

        LENGTH      : NATURAL;

        ERROR_STATE : NATURAL range 0 .. 2 := 0;

    begin

        loop
            begin

                TERMINAL_INTERFACE.PUT_LINE (PROMPT (PROMPT'RANGE));

                UTILITIES.GET_DICTIONARY_NAME (DICTIONARY_NAME, LENGTH);

                if  LENGTH =  UTILITIES.TERMINAL_DEVICE'LENGTH then

                    ERROR_STATE := ERROR_STATE + 1;

                    TERMINAL_INTERFACE.PUT_LINE
                       (" The file name must be specified.");

                    if ERROR_STATE > 1 then
                        raise TERMINATE_ERROR;
                    end if;

                else

                    TEXT_IO.OPEN
                       (FILE, TEXT_IO.IN_FILE,
                        DICTIONARY_NAME
                           (DICTIONARY_NAME'FIRST .. LENGTH));

                    exit;
                end if;

            exception

                when TEXT_IO.STATUS_ERROR | CONSTRAINT_ERROR |
                     TEXT_IO.NAME_ERROR =>

                    ERROR_STATE := ERROR_STATE + 1;

                    TERMINAL_INTERFACE.PUT_LINE
                       (" Dictionary name <<" &
                        DICTIONARY_NAME
                           (DICTIONARY_NAME'FIRST .. LENGTH) &
                        ">> is an invalid name");

                    if ERROR_STATE > 1 then
                        raise TERMINATE_ERROR;
                    end if;
            end;
        end loop;
    end GET_AND_OPEN_DICTIONARY;

------------------------------
-- end of the local procedure
------------------------------



------------------------------
-- start of the main procecure
------------------------------


begin

    TERMINAL_INTERFACE.NEW_PAGE;

    TERMINAL_INTERFACE.PUT_LINE (HELP_COMMAND);

    TERMINAL_INTERFACE.NEW_LINE;

    GET_AND_OPEN_DICTIONARY
       (DICTIONARY_NAME_1, DICTIONARY_PROMPT_1, INPUT_FILE_A);

--------------------------------------------
-- get the second dictionary
--------------------------------------------

    loop

        TERMINAL_INTERFACE.NEW_LINE;

        GET_AND_OPEN_DICTIONARY
           (DICTIONARY_NAME_2, DICTIONARY_PROMPT_2, INPUT_FILE_B);

        if TEXT_IO.NAME (INPUT_FILE_B) =
           TEXT_IO.NAME (INPUT_FILE_A) then

            ERROR_OCCURRENCE := ERROR_OCCURRENCE + 1;
            TERMINAL_INTERFACE.PUT_LINE
               ("Dictionary name <<" & TEXT_IO.NAME (INPUT_FILE_B) &
                ">> is currently open." );
            TERMINAL_INTERFACE.PUT_LINE
               (" Cannot merge a dictionary with itself");
            TEXT_IO.CLOSE (INPUT_FILE_B);
            if ERROR_OCCURRENCE > 1 then
                raise TERMINATE_ERROR;
            end if;
        else
            exit;
        end if;
    end loop;
--------------------------------------------
-- work on the third dictionary
--------------------------------------------
    ERROR_OCCURRENCE := 0;

    loop

        TERMINAL_INTERFACE.NEW_LINE;

        TERMINAL_INTERFACE.PUT_LINE (DICTIONARY_PROMPT_3);

        UTILITIES.GET_DICTIONARY_NAME (DICTIONARY_NAME_3, NAME_LENGTH);

        if DICTIONARY_NAME_3 = DICTIONARY_NAME_1 then
            UTILITIES.MERGE (INPUT_FILE_A, INPUT_FILE_B, INPUT_FILE_A);

            exit;      -- Merge operation is complete

        elsif DICTIONARY_NAME_3 = DICTIONARY_NAME_2 then
            UTILITIES.MERGE (INPUT_FILE_A, INPUT_FILE_B, INPUT_FILE_B);

            exit;      -- Merge operation is complete

        elsif NAME_LENGTH = UTILITIES.TERMINAL_DEVICE'LENGTH then

            ERROR_OCCURRENCE := ERROR_OCCURRENCE + 1;

            TERMINAL_INTERFACE.PUT_LINE
               ("A file name must be specified.");

            if ERROR_OCCURRENCE > 1 then
                raise TERMINATE_ERROR;
            end if;

        else
            begin
                UTILITIES.CREATE
                   (DICTIONARY_NAME_3
                       (DICTIONARY_NAME_3'FIRST .. NAME_LENGTH),
                    OUTPUT_FILE);

                UTILITIES.MERGE
                   (INPUT_FILE_A, INPUT_FILE_B, OUTPUT_FILE);

                exit;    -- Merge operation is complete

            exception
                when TEXT_IO.NAME_ERROR | CONSTRAINT_ERROR =>

                    ERROR_OCCURRENCE := ERROR_OCCURRENCE + 1;

                    TERMINAL_INTERFACE.PUT_LINE
                       (" Dictionary Name <<" &
                        DICTIONARY_NAME_3
                           (DICTIONARY_NAME_3'FIRST .. NAME_LENGTH) &
                        ">> is invalid.");

                    if ERROR_OCCURRENCE > 1 then
                        raise TERMINATE_ERROR;
                    end if;
            end;
        end if;
    end loop;

exception

---------------------------------------------------
-- the user has requested help. Provide the help
-- information.
---------------------------------------------------

    when NEEDS_HELP =>  HELP.HELP_SCREEN (HELP_LEVEL);

-----------------------------------------------
-- if the user has suppiled a invalid file name
-- to many times.  Terminate this operaiton.
-----------------------------------------------

    when TERMINATE_ERROR =>
        TERMINAL_INTERFACE.PUT_LINE ("This operation is terminated.");
        delay (TIME_PERIOD);

------------------------------------------------
-- The user choose not to execute this operation
------------------------------------------------

    when ABANDON =>  null;

end BEGIN_MERGE_OPERATIONS;

--****************************************************************
--****************************************************************

--------------------------------------------------------------------------
-- Abstract   : This operation will list out a user dictionary either
--            : to the terminal device or to a file designated by the user.
--------------------------------------------------------------------------
-- Parameters :
--
--------------------------------------------------------------------------
-- Algorithm  :
--
--------------------------------------------------------------------------

procedure BEGIN_DICTIONARY_LIST is

    HELP_LEVEL             : constant HELP.LEVEL_TYPE := HELP.LIST_HELP;

    INPUT_FILE             : TEXT_IO.FILE_TYPE;

    TOKEN                  : TOKEN_DEFINITION.TOKEN_TYPE;

    HELP_COMMAND           : constant STRING :=
                             (" For Help in this operation hit '?'");

    DICTIONARY_PROMPT_1    : constant STRING :=
                             ("Enter dictionary name to be listed.");

    DICTIONARY_PROMPT_2    : constant STRING :=
                             ("Ouptut dictionary name (space = screen).");

    INPUT_DICTIONARY_NAME  : STRING
                               (1 .. MACHINE_DEPENDENCIES
                                      .MAX_FILE_NAME_LENGTH);

    OUTPUT_DICTIONARY_NAME : STRING
                               (1 .. MACHINE_DEPENDENCIES
                                      .MAX_FILE_NAME_LENGTH);

    INPUT_NAME_LENGTH      : NATURAL;

    OUTPUT_NAME_LENGTH     : NATURAL;

    ERROR_OCCURRENCE       : NATURAL range 0 .. 2 := 0;

    NEEDS_HELP                  : exception renames UTILITIES.NEEDS_HELP;

    INVALID_INPUT_FILE          : exception renames UTILITIES
                                                     .INVALID_INPUT_FILE;

    INVALID_OUTPUT_FILE         : exception renames UTILITIES
                                                     .INVALID_OUTPUT_FILE;

    REPEAT_GET_INPUT_DICTIONARY : exception;

    ABANDON                     : exception renames UTILITIES.ABANDON;

    TERMINATE_ERROR             : exception;




begin

    TERMINAL_INTERFACE.NEW_PAGE;

    TERMINAL_INTERFACE.PUT_LINE (HELP_COMMAND);

    loop
        begin
            TERMINAL_INTERFACE.PUT_LINE (DICTIONARY_PROMPT_1);

            UTILITIES.GET_DICTIONARY_NAME
               (INPUT_DICTIONARY_NAME, INPUT_NAME_LENGTH);

            if INPUT_NAME_LENGTH = UTILITIES.TERMINAL_DEVICE'LENGTH then
                TERMINAL_INTERFACE.PUT_LINE
                   ("A file name must be specified.");

                ERROR_OCCURRENCE := ERROR_OCCURRENCE + 1;

                if ERROR_OCCURRENCE > 1 then
                    raise TERMINATE_ERROR;
                end if;
            else
                TERMINAL_INTERFACE.NEW_LINE;

                TERMINAL_INTERFACE.PUT_LINE (DICTIONARY_PROMPT_2);

                UTILITIES.GET_DICTIONARY_NAME
                   (OUTPUT_DICTIONARY_NAME, OUTPUT_NAME_LENGTH);

                if OUTPUT_DICTIONARY_NAME(OUTPUT_DICTIONARY_NAME'FIRST ..
                       OUTPUT_NAME_LENGTH) =
                   INPUT_DICTIONARY_NAME(INPUT_DICTIONARY_NAME'FIRST ..
                       INPUT_NAME_LENGTH) then

                       TERMINAL_INTERFACE.PUT_LINE
                       ("Dictionary name <<" &

                       INPUT_DICTIONARY_NAME(INPUT_DICTIONARY_NAME'FIRST ..
                              INPUT_NAME_LENGTH)
                       & ">> cannot be used for both input and output.");

                       ERROR_OCCURRENCE := ERROR_OCCURRENCE + 1;

                       if ERROR_OCCURRENCE > 1 then
                          raise TERMINATE_ERROR;
                       else
                          raise REPEAT_GET_INPUT_DICTIONARY;
                       end if;
                elsif
                      OUTPUT_NAME_LENGTH = UTILITIES.TERMINAL_DEVICE'LENGTH
                    then
                    loop
                        begin
                            TEXT_IO.OPEN
                               (INPUT_FILE, TEXT_IO.IN_FILE,
                                INPUT_DICTIONARY_NAME
                                   (INPUT_DICTIONARY_NAME'FIRST ..
                                    INPUT_NAME_LENGTH));
                            exit;
                        exception
                            when others =>
                                TERMINAL_INTERFACE.PUT_LINE
                                   ("Dictionary name <<" &
                                    INPUT_DICTIONARY_NAME
                                       (INPUT_DICTIONARY_NAME'FIRST ..
                                        INPUT_NAME_LENGTH) &
                                    ">> is invalid");

                                ERROR_OCCURRENCE :=
                                  ERROR_OCCURRENCE + 1;

                                if ERROR_OCCURRENCE > 1 then
                                    raise TERMINATE_ERROR;
                                else
                                    raise REPEAT_GET_INPUT_DICTIONARY;
                                end if;
                        end;
                    end loop;

                    ERROR_OCCURRENCE := 0;

                    TERMINAL_INTERFACE.NEW_LINE;

                    while not TEXT_IO.END_OF_FILE (INPUT_FILE) loop
                        TEXT_IO.GET_LINE
                           (INPUT_FILE, TOKEN.WORD, TOKEN.LENGTH);

                        TERMINAL_INTERFACE.PUT_LINE
                           (TOKEN.WORD
                               (TOKEN.WORD'FIRST .. TOKEN.LENGTH));
                    end loop;
                    TEXT_IO.CLOSE(INPUT_FILE);
                else
                    UTILITIES.LIST
                       (INPUT_DICTIONARY_NAME
                           (INPUT_DICTIONARY_NAME'FIRST ..
                            INPUT_NAME_LENGTH),
                        OUTPUT_DICTIONARY_NAME
                           (OUTPUT_DICTIONARY_NAME'FIRST ..
                            OUTPUT_NAME_LENGTH));


                end if;
                exit;
            end if;
        exception

---------------------------------------------------
-- the user has requested help. Provide the help
-- information.
---------------------------------------------------

            when NEEDS_HELP =>  HELP.HELP_SCREEN (HELP_LEVEL);

            when REPEAT_GET_INPUT_DICTIONARY =>  null;

            when INVALID_INPUT_FILE | INVALID_OUTPUT_FILE =>
                TERMINAL_INTERFACE.PUT_LINE
                   (" Dictionary name <<" &
                    INPUT_DICTIONARY_NAME
                       (INPUT_DICTIONARY_NAME'FIRST ..
                        INPUT_NAME_LENGTH) &
                    ">> or dictionary name <<" &
                    OUTPUT_DICTIONARY_NAME
                       (OUTPUT_DICTIONARY_NAME'FIRST ..
                        OUTPUT_NAME_LENGTH) & ">> is invalid.");

                ERROR_OCCURRENCE := ERROR_OCCURRENCE + 1;

                if ERROR_OCCURRENCE > 1 then
                    raise TERMINATE_ERROR;
                end if;
        end;
    end loop;
exception
    when ABANDON =>  null;

    when TERMINATE_ERROR =>
        TERMINAL_INTERFACE.PUT_LINE ("This opeation is terminated");
        delay (TIME_PERIOD);

    when others =>   raise;

end BEGIN_DICTIONARY_LIST;

--****************************************************************
--****************************************************************


begin

-----------------------------------------------------------
-- Since the application does not allow for screen adressing
-- the menus (or pages displayed) must be cleared prior to
-- displaying the next menu.  To give the user time to read
-- to read the menue (page) execution will be delayed for
-- a specified amount of time.
-----------------------------------------------------------


    begin
        COMMAND_LINE_INTERFACE.FILE_NAME(USER_INFO.DOCUMENT.NAME,
                                         USER_INFO.DOCUMENT.LENGTH);

        if USER_INFO.DOCUMENT.LENGTH >= USER_INFO.DOCUMENT.NAME'FIRST
           then USER_INFO.MODE := GET_USER_INFO.DISABLED;
                PROCESSING_COMMAND_LINE := TRUE;
        end if;

        COMMAND_LINE_INTERFACE.WORD_LIST(USER_INFO.WORD_LIST.NAME,
                                         USER_INFO.WORD_LIST.LENGTH);

        if USER_INFO.WORD_LIST.LENGTH < USER_INFO.WORD_LIST.NAME'FIRST
           and PROCESSING_COMMAND_LINE then
              raise INVALID_EXECUTION_ATTEMPTED;

        elsif USER_INFO.WORD_LIST.LENGTH >= USER_INFO.WORD_LIST.NAME'FIRST
           and not PROCESSING_COMMAND_LINE then
              raise INVALID_EXECUTION_ATTEMPTED;
        else null;
        end if;

        COMMAND_LINE_INTERFACE.MASTER_DICTIONARY
                           (USER_RESPONSE, NUMBER_OF_CHARACTERS);

        if NUMBER_OF_CHARACTERS >= USER_RESPONSE'FIRST
           and PROCESSING_COMMAND_LINE then
            USER_INFO.MASTER := TRUE;

        elsif NUMBER_OF_CHARACTERS >= USER_RESPONSE'FIRST
              and not PROCESSING_COMMAND_LINE then
              raise INVALID_EXECUTION_ATTEMPTED;

        else
          USER_INFO.MASTER := FALSE;
        end if;

        COMMAND_LINE_INTERFACE.ACRONYM_DICTIONARY
                           (USER_RESPONSE, NUMBER_OF_CHARACTERS);

        if NUMBER_OF_CHARACTERS >= USER_RESPONSE'FIRST
           and PROCESSING_COMMAND_LINE then
            USER_INFO.ACRONYM := TRUE;

        elsif NUMBER_OF_CHARACTERS >= USER_RESPONSE'FIRST
              and not PROCESSING_COMMAND_LINE then
              raise INVALID_EXECUTION_ATTEMPTED;

        else
          USER_INFO.ACRONYM := FALSE;
        end if;

        for I in 1 .. GET_USER_INFO.NUMBER_OF_USER_DICTIONARIES loop

           COMMAND_LINE_INTERFACE.USER_DICTIONARY
                         (I, USER_RESPONSE, NUMBER_OF_CHARACTERS);

           exit when NUMBER_OF_CHARACTERS = 0;

           if NUMBER_OF_CHARACTERS >= USER_RESPONSE'FIRST then

              USER_INFO.USER_DICT.MODE := GET_USER_INFO.ENABLED;
              USER_INFO.USER_DICT.NAMES(I).NAME := USER_RESPONSE;
              USER_INFO.USER_DICT.NAMES(I).LENGTH := NUMBER_OF_CHARACTERS;
              USER_INFO.USER_DICT.NAMES(I).MODE := GET_USER_INFO.ENABLED;
           end if;


        end loop;

        if USER_INFO.USER_DICT.MODE = GET_USER_INFO.ENABLED
              and not PROCESSING_COMMAND_LINE then
               raise INVALID_EXECUTION_ATTEMPTED;
        end if;
    exception
        when COMMAND_LINE_INTERFACE.NAME_ERROR  =>
               TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                    "Invalid syntax on invocation");
               raise ABANDON;

        when COMMAND_LINE_INTERFACE.MIX_ERROR  =>
               TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                    "Named association and positional association " &
                    "improperly mixed on command line.");
               raise ABANDON;

        when COMMAND_LINE_INTERFACE.USER_DICTIONARY_NUMBER =>
               TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                    "Invalid user dictionary request");
               raise ABANDON;

        when INVALID_EXECUTION_ATTEMPTED =>
               TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                    "No document or no suspect word list supplied.");
               raise ABANDON;
    end ;

    if PROCESSING_COMMAND_LINE then
        PROCESS_PACKAGE.BATCH_PROCESS(USER_INFO);

    else

    DISPLAY_TITLE_PAGE;
    delay (TIME_PERIOD);

        loop
           begin
-----------------------------------------------------------------
-- This is the operations menu the user must deal with first.
-- The operations available include
--
--           MERGE
--           LIST
--           QUIT
--           HELP
--           SPELL
--
-- At the conclusion of any of these operations the user will be
-- prompted for further action.  Eventually the user will choose
-- quit.  At this time the program terminates.
-----------------------------------------------------------------

            DISPLAY_COMMAND_CHOICES;

            TERMINAL_INTERFACE.GET_LINE
                     (USER_RESPONSE, NUMBER_OF_CHARACTERS);

            case USER_RESPONSE (USER_RESPONSE'FIRST) is

                when '?' =>  HELP.HELP_SCREEN (LEVEL_1);

                when 'S' | 's' =>  BEGIN_DOCUMENT_CHECK;

                when 'Q' | 'q' =>  exit;

                when 'M' | 'm' =>  BEGIN_MERGE_OPERATIONS;

                when 'L' | 'l' =>  BEGIN_DICTIONARY_LIST;

                when others =>
                    TERMINAL_INTERFACE.NEW_LINE;

                    TERMINAL_INTERFACE.PUT_LINE
                        ("<<" & USER_RESPONSE
                                   (USER_RESPONSE'FIRST ..
                                NUMBER_OF_CHARACTERS) & ">>" );

                    TERMINAL_INTERFACE.PUT_LINE
                       (" is not one of your possible choices ");

                    TERMINAL_INTERFACE.PUT_LINE
                       (" Reenter your choice ");

                    delay (TIME_PERIOD); -- allow the user to see
                                         -- the improper response
            end case;

            USER_RESPONSE := (USER_RESPONSE'RANGE => ' ');

           exception
                when HELP.HELP_FILE_ERROR =>
                     TERMINAL_INTERFACE.PUT_LINE
                        ("The HELP file does not exist.");
                     TERMINAL_INTERFACE.PUT_LINE
                        ("No HELP information is available.");

                when HELP.HELP_OPEN_ERROR =>
                     TERMINAL_INTERFACE.PUT_LINE
                        ("The HELP file could not be opened.");
                     TERMINAL_INTERFACE.PUT_LINE
                        ("No HELP information is available.");

                when HELP.HELP_FORMAT_ERROR =>
                     TERMINAL_INTERFACE.PUT_LINE
                        ("The format of the HELP file is not legal.");
                     TERMINAL_INTERFACE.PUT_LINE
                        ("No HELP information is available.");
           end;

        end loop;

    end if;

exception
    when ABANDON => null;

    when INVALID_EXECUTION_ATTEMPTED =>
                TEXT_IO.PUT_LINE(TEXT_IO.STANDARD_OUTPUT,
                 "Invalid execution attempted.");

    when others => null;

end SPELLER;
::::::::::
SPELLER_MASTER.DCT
::::::::::
aback
abaft
abandon
abandoned
abandoning
abandons
abandonment
abase
abased
abasing
abases
abasement
abasements
abash
abashed
abashing
abashes
abate
abated
abater
abating
abates
abatement
abatements
abbe
abbey
abbey's
abbeys
abbot
abbot's
abbots
abbreviate
abbreviated
abbreviating
abbreviation
abbreviations
abbreviates
abdomen
abdomen's
abdomens
abdominal
abduct
abducted
abducts
abduction
abduction's
abductions
abductor
abductor's
abductors
abed
aberrant
aberration
aberrations
abet
abets
abetted
abetter
abetting
abeyance
abhor
abhors
abhorred
abhorrent
abhorrer
abhorring
abide
abided
abiding
abides
ability
ability's
abilities
abject
abjectness
abjectly
abjection
abjections
abjure
abjured
abjuring
abjures
ablate
ablated
ablating
ablation
ablative
ablates
ablaze
able
ablest
abler
ablute
ably
abnormal
abnormally
abnormality
abnormalities
aboard
abode
abode's
abodes
abolish
abolished
abolisher
abolishers
abolishing
abolishes
abolishment
abolishment's
abolishments
abolition
abolitionist
abolitionists
abominable
aboriginal
aborigine
aborigine's
aborigines
abort
aborted
aborting
abortive
aborts
abortion
abortion's
abortions
abortive
abortively
abound
abounded
abounding
abounds
about
above
aboveground
abrade
abraded
abrading
abrades
abrasion
abrasion's
abrasions
abreaction
abreactions
abreast
abridge
abridged
abridging
abridges
abridgment
abroad
abrogate
abrogated
abrogating
abrogates
abrupt
abruptness
abruptly
abscess
abscessed
abscesses
abscissa
abscissa's
abscissas
abscond
absconded
absconding
absconds
absence
absence's
absences
absent
absented
absenting
absently
absents
absentee
absentee's
absentees
absenteeism
absentia
absentminded
absinthe
absolute
absoluteness
absolution
absolutely
absolutes
absolve
absolved
absolving
absolves
absorb
absorbed
absorber
absorbing
absorbs
absorbency
absorbent
absorption
absorption's
absorptions
absorptive
abstain
abstained
abstainer
abstaining
abstains
abstention
abstentions
abstinence
abstract
abstractness
abstracted
abstracting
abstractly
abstracts
abstraction
abstraction's
abstractions
abstractionism
abstractionist
abstractor
abstractor's
abstractors
abstruse
abstruseness
absurd
absurdly
absurdity
absurdity's
absurdities
abundance
abundant
abundantly
abuse
abused
abusing
abusive
abuses
abut
abuts
abutment
abutted
abutter
abutter's
abutters
abutting
abysmal
abysmally
abyss
abyss's
abysses
acacia
academia
academic
academics
academically
academy
academy's
academies
accede
acceded
accedes
accelerate
accelerated
accelerating
acceleration
accelerations
accelerates
accelerator
accelerators
accelerometer
accelerometer's
accelerometers
accent
accented
accenting
accents
accentual
accentuate
accentuated
accentuating
accentuation
accentuates
accept
accepted
accepter
accepters
accepting
accepts
acceptability
acceptable
acceptably
acceptance
acceptance's
acceptances
acceptor
acceptor's
acceptors
access
accessed
accessing
accesses
accessibility
accessible
accessibly
accession
accession's
accessions
accessor
accessor's
accessors
accessory
accessory's
accessories
accident
accidently
accidents
accidental
accidentally
acclaim
acclaimed
acclaiming
acclaims
acclamation
acclimate
acclimated
acclimating
acclimates
acclimatization
acclimatized
accolade
accolades
accommodate
accommodated
accommodating
accommodation
accommodations
accommodates
accompaniment
accompaniment's
accompaniments
accompanist
accompanist's
accompanists
accompany
accompanied
accompanying
accompanies
accomplice
accomplices
accomplish
accomplished
accomplisher
accomplishers
accomplishing
accomplishes
accomplishment
accomplishment's
accomplishments
accord
accorded
accorder
accorders
according
accords
accordance
accordingly
accordion
accordion's
accordions
accost
accosted
accosting
accosts
account
accounted
accounting
accounts
accountability
accountable
accountably
accountancy
accountant
accountant's
accountants
accoutrement
accoutrements
accredit
accredited
accreditation
accreditations
accretion
accretion's
accretions
accrue
accrued
accruing
accrues
acculturate
acculturated
acculturating
acculturation
acculturates
accumulate
accumulated
accumulating
accumulation
accumulations
accumulates
accumulator
accumulator's
accumulators
accuracy
accuracies
accurate
accurateness
accurately
accursed
accusal
accusation
accusation's
accusations
accusative
accuse
accused
accuser
accusing
accuses
accusingly
accustom
accustomed
accustoming
accustoms
ace
ace's
aces
acetate
acetone
acetylene
ache
ached
aching
aches
achievable
achieve
achieved
achiever
achievers
achieving
achieves
achievement
achievement's
achievements
achilles
acid
acidly
acids
acidic
acidity
acidities
acidulous
acknowledge
acknowledged
acknowledger
acknowledgers
acknowledging
acknowledges
acknowledgment
acknowledgment's
acknowledgments
acme
acne
acolyte
acolytes
acorn
acorn's
acorns
acoustic
acoustics
acoustical
acoustically
acoustician
acquaint
acquainted
acquainting
acquaints
acquaintance
acquaintance's
acquaintances
acquiesce
acquiesced
acquiescing
acquiesces
acquiescence
acquirable
acquire
acquired
acquiring
acquires
acquisition
acquisition's
acquisitions
acquisitiveness
acquit
acquits
acquittal
acquitted
acquitter
acquitting
acre
acre's
acres
acreage
acrid
acrimonious
acrimony
acrobat
acrobat's
acrobats
acrobatic
acrobatics
acronym
acronym's
acronyms
acropolis
across
acrylic
act
acted
acting
active
acts
actinium
actinometer
actinometers
action
action's
actions
activate
activated
activating
activation
activations
activates
activator
activator's
activators
actively
activism
activist
activist's
activists
activity
activity's
activities
actor
actor's
actors
actress
actress's
actresses
actual
actually
actuals
actuality
actualities
actualization
actuarial
actuarially
actuate
actuated
actuating
actuates
actuator
actuator's
actuators
acuity
acumen
acute
acuteness
acutely
acyclic
acyclically
ad
adage
adages
adagio
adagios
adamant
adamantly
adapt
adapted
adapter
adapters
adapting
adaptive
adapts
adaptability
adaptable
adaptation
adaptation's
adaptations
adaptively
adaptor
adaptors
add
added
adder
adders
adding
adds
addenda
addendum
addict
addicted
addicting
addicts
addiction
addiction's
addictions
addition
addition's
additions
additional
additionally
additive
additive's
additives
additivity
address
addressed
addresser
addressers
addressing
addresses
addressability
addressable
addressee
addressee's
addressees
adduce
adduced
adducing
adduces
adducible
adduct
adducted
adducting
adducts
adduction
adductor
adept
adequacy
adequacies
adequate
adequately
adhere
adhered
adherer
adherers
adhering
adheres
adherence
adherent
adherent's
adherents
adhesion
adhesions
adhesive
adhesive's
adhesives
adiabatic
adiabatically
adieu
adjacency
adjacent
adjective
adjective's
adjectives
adjoin
adjoined
adjoining
adjoins
adjourn
adjourned
adjourning
adjourns
adjournment
adjudge
adjudged
adjudging
adjudges
adjudicate
adjudicated
adjudicating
adjudicates
adjudication
adjudication's
adjudications
adjunct
adjunct's
adjuncts
adjure
adjured
adjuring
adjures
adjust
adjusted
adjuster
adjusters
adjusting
adjusts
adjustable
adjustably
adjustment
adjustment's
adjustments
adjustor
adjustor's
adjustors
adjutant
adjutants
administer
administered
administering
administerings
administers
administration
administration's
administrations
administrative
administratively
administrator
administrator's
administrators
admirable
admirably
admiral
admiral's
admirals
admiralty
admiration
admirations
admire
admired
admirer
admirers
admiring
admires
admiring
admiringly
admissibility
admissible
admission
admission's
admissions
admit
admits
admittance
admitted
admittedly
admitter
admitters
admitting
admix
admixed
admixes
admixture
admonish
admonished
admonishing
admonishes
admonishment
admonishment's
admonishments
admonition
admonition's
admonitions
ado
adobe
adolescence
adolescent
adolescent's
adolescents
adopt
adopted
adopter
adopters
adopting
adoptive
adopts
adoption
adoption's
adoptions
adorable
adoration
adore
adored
adores
adorn
adorned
adorns
adornment
adornment's
adornments
adrenal
adrenaline
adrift
adroit
adroitness
ads
adsorb
adsorbed
adsorbing
adsorbs
adsorption
adulation
adult
adult's
adults
adulterate
adulterated
adulterating
adulterates
adulterer
adulterer's
adulterers
adulterous
adulterously
adultery
adulthood
adumbrate
adumbrated
adumbrating
adumbrates
advance
advanced
advancing
advances
advancement
advancement's
advancements
advantage
advantaged
advantages
advantageous
advantageously
advent
adventist
adventists
adventitious
adventure
adventured
adventurer
adventurers
adventuring
adventures
adventurous
adverb
adverb's
adverbs
adverbial
adversary
adversary's
adversaries
adverse
adversely
adversity
adversities
advertise
advertised
advertiser
advertisers
advertising
advertises
advertisement
advertisement's
advertisements
advice
advisability
advisable
advisably
advise
advised
adviser
advisers
advising
advises
advisedly
advisee
advisee's
advisees
advisement
advisements
advisor
advisor's
advisors
advisory
advocacy
advocate
advocated
advocating
advocates
aegis
aerate
aerated
aerating
aeration
aerates
aerator
aerators
aerial
aerial's
aerials
aeroacoustic
aerobic
aerobics
aerodynamic
aerodynamics
aeronautic
aeronautics
aeronautical
aerosol
aerosols
aerosolize
aerospace
aesthetic
aesthetic's
aesthetics
aesthetically
afar
affable
affair
affair's
affairs
affect
affected
affecting
affective
affects
affectation
affectation's
affectations
affectingly
affection
affection's
affections
affectionate
affectionately
affector
afferent
affianced
affidavit
affidavit's
affidavits
affiliate
affiliated
affiliating
affiliation
affiliations
affiliates
affinity
affinity's
affinities
affirm
affirmed
affirming
affirms
affirmation
affirmation's
affirmations
affirmative
affirmatively
affix
affixed
affixing
affixes
afflict
afflicted
afflicting
afflictive
afflicts
affliction
affliction's
afflictions
affluence
affluent
afford
afforded
affording
affords
affordable
affricate
affricates
affright
affront
affronted
affronting
affronts
Afghan
Afghans
Afghanistan
aficionado
afield
afire
aflame
afloat
afoot
afore
aforementioned
aforesaid
aforethought
afoul
afraid
afresh
Africa
African
Africans
aft
after
aftereffect
aftermath
aftermost
afternoon
afternoon's
afternoons
aftershock
aftershocks
afterthought
afterthoughts
afterward
afterwards
again
against
agape
agar
agate
agates
age
aged
ager
agers
aging
ages
ageless
agency
agency's
agencies
agenda
agenda's
agendas
agent
agent's
agents
agglomerate
agglomerated
agglomeration
agglomerates
agglutinate
agglutinated
agglutinating
agglutination
agglutinates
agglutinin
agglutinins
aggravate
aggravated
aggravation
aggravates
aggregate
aggregated
aggregating
aggregation
aggregations
aggregately
aggregates
aggression
aggression's
aggressions
aggressive
aggressiveness
aggressively
aggressor
aggressors
aggrieve
aggrieved
aggrieving
aggrieves
aghast
agile
agilely
agility
agitate
agitated
agitating
agitation
agitations
agitates
agitator
agitator's
agitators
agleam
aglow
agnostic
agnostic's
agnostics
ago
agog
agonize
agonized
agonizing
agonizes
agony
agonies
agrarian
agree
agreed
agreer
agreers
agrees
agreeable
agreeableness
agreeably
agreeing
agreement
agreement's
agreements
agricultural
agriculturally
agriculture
ague
ah
ahead
aid
aided
aiding
aids
aide
aided
aiding
aides
ail
ailing
aileron
ailerons
ailment
ailment's
ailments
aim
aimed
aimer
aimers
aiming
aims
aimless
aimlessly
air
aired
airer
airers
airing
airings
airs
airbag
airbags
airborne
aircraft
airdrop
airdrops
Airedale
airfield
airfield's
airfields
airflow
airfoil
airfoils
airframe
airframes
airily
airless
airlift
airlift's
airlifts
airline
airliner
airlines
airlock
airlock's
airlocks
airmail
airmails
airman
airmen
airplane
airplane's
airplanes
airport
airport's
airports
airship
airship's
airships
airspace
airspeed
airstrip
airstrip's
airstrips
airway
airway's
airways
airy
aisle
ajar
akimbo
akin
Alabama
Alabamian
alabaster
alacrity
alarm
alarmed
alarming
alarms
alarmingly
alarmist
alas
Alaska
alba
albacore
Albania
Albanian
Albanians
albeit
album
albums
albumin
alchemy
alcibiades
alcohol
alcohol's
alcohols
alcoholic
alcoholic's
alcoholics
alcoholism
alcove
alcove's
alcoves
alden
alder
alderman
alderman's
aldermen
ale
alive
alee
alert
alertness
alerted
alerter
alerters
alerting
alertly
alerts
alertedly
alfalfa
alfresco
alga
algae
algaecide
algebra
algebra's
algebras
algebraic
algebraically
Algeria
Algerian
alginate
algol
algorithm
algorithm's
algorithms
algorithmic
algorithmically
alias
aliased
aliasing
aliases
alibi
alibi's
alibis
alien
alien's
aliens
alienate
alienated
alienating
alienation
alienates
alight
align
aligned
aligning
aligns
alignment
alignments
alike
aliment
aliments
alimony
alkali
alkali's
alkalis
alkaline
alkaloid
alkaloid's
alkaloids
alkyl
all
Allah
Allah's
allay
allayed
allaying
allays
allegation
allegation's
allegations
allege
alleged
alleging
alleges
allegedly
allegiance
allegiance's
allegiances
allegoric
allegorical
allegorically
allegory
allegory's
allegories
allegretto
allegretto's
allegrettos
allegro
allegro's
allegros
allele
alleles
allemande
allergic
allergy
allergy's
allergies
alleviate
alleviated
alleviater
alleviaters
alleviating
alleviation
alleviates
alley
alley's
alleys
alleyway
alleyway's
alleyways
alliance
alliance's
alliances
alligator
alligator's
alligators
alliteration
alliteration's
alliterations
alliterative
allocate
allocated
allocating
allocation
allocations
allocates
allocator
allocator's
allocators
allophone
allophones
allophonic
allot
allots
allotment
allotment's
allotments
allotted
allotter
allotting
allow
allowed
allowing
allows
allowable
allowably
allowance
allowance's
allowances
alloy
alloy's
alloys
allude
alluded
alluding
alludes
allure
alluring
allurement
allusion
allusion's
allusions
allusive
allusiveness
ally
allied
allying
allies
alma
almanac
almanac's
almanacs
almighty
almond
almond's
almonds
almoner
almost
alms
almsman
alnico
aloe
aloes
aloft
aloha
alone
aloneness
along
alongside
aloof
aloofness
aloud
alpha
alphabet
alphabet's
alphabets
alphabetic
alphabetics
alphabetical
alphabetically
alphabetize
alphabetized
alphabetizing
alphabetizes
alphanumeric
Alpine
Alps
already
also
altar
altar's
altars
alter
altered
alterer
alterers
altering
alters
alterable
alteration
alteration's
alterations
altercation
altercation's
altercations
alternate
alternated
alternating
alternation
alternations
alternative
alternately
alternates
alternative
alternatively
alternatives
alternator
alternator's
alternators
although
altitude
alto
alto's
altos
altogether
altruism
altruist
altruistic
altruistically
alum
aluminum
alumna
alumna's
alumnae
alumni
alumnus
alundum
alveolar
alveoli
alveolus
always
am
amen
amain
amalgam
amalgam's
amalgams
amalgamate
amalgamated
amalgamating
amalgamation
amalgamates
amanuensis
amass
amassed
amassing
amasses
amateur
amateur's
amateurs
amateurish
amateurishness
amateurism
amatory
amaze
amazed
amazer
amazers
amazing
amazes
amazedly
amazement
amazing
amazingly
amazon
amazon's
amazons
ambassador
ambassador's
ambassadors
amber
ambiance
ambidextrous
ambidextrously
ambient
ambiguity
ambiguity's
ambiguities
ambiguous
ambiguously
ambition
ambition's
ambitions
ambitious
ambitiously
ambivalence
ambivalent
ambivalently
amble
ambled
ambler
ambling
ambles
ambrosial
ambulance
ambulance's
ambulances
ambulatory
ambuscade
ambush
ambushed
ambushes
amelia
ameliorate
ameliorated
ameliorating
amenable
amend
amended
amending
amends
amendment
amendment's
amendments
amenity
amenities
amenorrhea
America
America's
Americas
American
American's
Americans
Americana
Americium
amiable
amicable
amicably
amid
amide
amidst
amigo
amino
amiss
amity
ammo
ammonia
ammoniac
ammonium
ammunition
amnesty
amoeba
amoeba's
amoebas
amok
among
amongst
amoral
amorality
amorist
amorous
amorphous
amorphously
amortize
amortized
amortizing
amortizes
amount
amounted
amounter
amounters
amounting
amounts
amour
amp
amply
amps
ampere
amperes
ampersand
ampersand's
ampersands
amphetamine
amphetamines
amphibian
amphibian's
amphibians
amphibious
amphibiously
amphibology
amphitheater
amphitheater's
amphitheaters
ample
amplify
amplified
amplifier
amplifiers
amplifying
amplification
amplifies
amplitude
amplitude's
amplitudes
ampoule
ampoule's
ampoules
amputate
amputated
amputating
amputates
Amsterdam
Amtrak
amulet
amulets
amuse
amused
amuser
amusers
amusing
amuses
amusedly
amusement
amusement's
amusements
amusingly
amyl
an
Anabaptist
Anabaptist's
Anabaptists
anachronism
anachronism's
anachronisms
anachronistically
anaconda
anacondas
anaerobic
anaesthesia
anagram
anagram's
anagrams
anal
analog
analogical
analogous
analogously
analogue
analogue's
analogues
analogy
analogy's
analogies
analyses
analysis
analyst
analyst's
analysts
analytic
analytical
analytically
analyticity
analyticities
analyzable
analyze
analyzed
analyzer
analyzers
analyzing
analyzes
anaphora
anaphoric
anaphorically
anaplasmosis
anarchic
anarchical
anarchist
anarchist's
anarchists
anarchy
anastomoses
anastomosis
anastomotic
anathema
anatomic
anatomical
anatomically
anatomy
ancestor
ancestor's
ancestors
ancestral
ancestry
anchor
anchored
anchoring
anchors
anchorage
anchorage's
anchorages
anchorite
anchoritism
anchovy
anchovies
ancient
anciently
ancients
ancillary
and
anders
anding
andorra
anecdotal
anecdote
anecdote's
anecdotes
anechoic
anemia
anemic
anemometer
anemometer's
anemometers
anemometry
anemone
anesthesia
anesthetic
anesthetic's
anesthetics
anesthetically
anesthetize
anesthetized
anesthetizing
anesthetizes
anew
angel
angel's
angels
angelic
anger
angered
angering
angers
angiography
angle
angled
angler
anglers
angling
angles
Anglican
Anglicans
Anglicanism
Anglophilia
Anglophobia
Angola
angrily
angry
angriest
angrier
angst
angstrom
anguish
anguished
angular
angularly
anhydrous
anhydrously
aniline
animal
animal's
animals
animate
animateness
animated
animating
animation
animations
animately
animates
animatedly
animator
animator's
animators
animism
animized
animosity
anion
anion's
anions
anionic
anise
aniseikonic
anisotropic
anisotropy
ankle
ankle's
ankles
annal
annals
annex
annexed
annexing
annexes
annexation
annihilate
annihilated
annihilating
annihilation
annihilates
anniversary
anniversary's
anniversaries
annotate
annotated
annotating
annotation
annotations
annotates
announce
announced
announcer
announcers
announcing
announces
announcement
announcement's
announcements
annoy
annoyed
annoying
annoys
annoyance
annoyance's
annoyances
annoyer
annoyers
annoyingly
annual
annually
annuals
annul
annuls
annulled
annulling
annulment
annulment's
annulments
annum
annunciate
annunciated
annunciating
annunciates
annunciator
annunciators
anode
anode's
anodes
anodize
anodized
anodizes
anoint
anointed
anointing
anoints
anomalous
anomalously
anomaly
anomaly's
anomalies
anomic
anomie
anon
anonymity
anonymous
anonymously
anorexia
another
another's
answer
answered
answerer
answerers
answering
answers
answerable
ant
ant's
ants
antagonism
antagonisms
antagonist
antagonist's
antagonists
antagonistic
antagonistically
antagonize
antagonized
antagonizing
antagonizes
Antarctic
Antarctica
ante
anteater
anteater's
anteaters
antecedent
antecedent's
antecedents
antedate
antelope
antelope's
antelopes
antenna
antenna's
antennas
antennae
anterior
anthem
anthem's
anthems
anther
anthology
anthologies
anthracite
anthropological
anthropologically
anthropologist
anthropologist's
anthropologists
anthropology
anthropomorphic
anthropomorphically
anti
antibacterial
antibiotic
antibiotics
antibody
antibodies
antic
antic's
antics
anticipate
anticipated
anticipating
anticipation
anticipations
anticipates
anticipatory
anticoagulation
anticompetitive
antidisestablishmentarianism
antidote
antidote's
antidotes
antiformant
antifundamentalist
antigen
antigen's
antigens
antihistorical
antimicrobial
antimony
antinomian
antinomy
antipathy
antiphonal
antipode
antipode's
antipodes
antiquarian
antiquarian's
antiquarians
antiquate
antiquated
antique
antique's
antiques
antiquity
antiquities
antiredeposition
antiresonance
antiresonator
antiseptic
antisera
antiserum
antislavery
antisocial
antisubmarine
antisymmetric
antisymmetry
antithesis
antithetical
antithyroid
antitoxin
antitoxin's
antitoxins
antitrust
antler
antlered
anus
anvil
anvil's
anvils
anxiety
anxieties
anxious
anxiously
any
anybody
anyhow
anymore
anyone
anyplace
anything
anytime
anyway
anywhere
aorta
apace
apart
apartheid
apartment
apartment's
apartments
apathetic
apathy
ape
aped
aping
apes
aperiodic
aperiodicity
aperture
apex
aphasia
aphasic
aphid
aphid's
aphids
aphonic
aphorism
aphorism's
aphorisms
aphrodite
apiary
apiaries
apical
apiece
apish
aplenty
aplomb
apocalypse
apocalyptic
apocrypha
apocryphal
apogee
apogees
apollo
apollonian
apologetic
apologetically
apologia
apologist
apologist's
apologists
apologize
apologized
apologizing
apologizes
apology
apology's
apologies
apostate
apostle
apostle's
apostles
apostolic
apostrophe
apostrophes
apothecary
apotheoses
apotheosis
appalachia
Appalachian
Appalachians
appall
appalled
appalling
appallingly
appanage
apparatus
apparel
appareled
apparent
apparently
apparition
apparition's
apparitions
appeal
appealed
appealer
appealers
appealing
appeals
appealingly
appear
appeared
appearer
appearers
appearing
appears
appearance
appearances
appease
appeased
appeasing
appeases
appeasement
appellant
appellant's
appellants
appellate
append
appended
appender
appenders
appending
appends
appendage
appendage's
appendages
appendices
appendicitis
appendix
appendix's
appendixes
appertain
appertains
appetite
appetite's
appetites
appetizer
appetizing
applaud
applauded
applauding
applauds
applause
apple
apple's
apples
applejack
appliance
appliance's
appliances
applicability
applicable
applicant
applicant's
applicants
application
application's
applications
applicative
applicatively
applicator
applicator's
applicators
applique
apply
applied
applier
appliers
applying
application
applications
applies
appoint
appointed
appointer
appointers
appointing
appointive
appoints
appointee
appointee's
appointees
appointment
appointment's
appointments
apportion
apportioned
apportioning
apportions
apportionment
apportionments
appraisal
appraisal's
appraisals
appraise
appraised
appraiser
appraisers
appraising
appraises
appraisingly
appreciable
appreciably
appreciate
appreciated
appreciating
appreciation
appreciations
appreciative
appreciates
appreciatively
apprehend
apprehended
apprehensible
apprehension
apprehension's
apprehensions
apprehensive
apprehensiveness
apprehensively
apprentice
apprenticed
apprentices
apprenticeship
apprise
apprised
apprising
apprises
approach
approached
approacher
approachers
approaching
approaches
approachability
approachable
approbate
approbation
appropriate
appropriateness
appropriated
appropriating
appropriation
appropriations
appropriately
appropriates
appropriator
appropriator's
appropriators
approval
approval's
approvals
approve
approved
approver
approvers
approving
approves
approvingly
approximate
approximated
approximating
approximation
approximations
approximately
approximates
appurtenance
appurtenances
apricot
apricot's
apricots
April
apron
apron's
aprons
apropos
apse
apsis
apt
aptness
aptly
aptitude
aptitudes
aqua
aquaria
aquarium
Aquarius
aquatic
aqueduct
aqueduct's
aqueducts
aqueous
aquifer
aquifers
Arab
Arab's
Arabs
arabesque
Arabia
Arabian
Arabians
Arabic
arable
arachnid
arachnid's
arachnids
arbiter
arbiter's
arbiters
arbitrarily
arbitrary
arbitrariness
arbitrate
arbitrated
arbitrating
arbitration
arbitrates
arbitrator
arbitrator's
arbitrators
arbor
arbor's
arbors
arboreal
arc
arced
arcing
arcs
arcade
arcaded
arcade's
arcades
arcane
arch
arched
archer
archers
arching
archly
arches
archaeological
archaeologist
archaeologist's
archaeologists
archaeology
archaic
archaicness
archaically
archaism
archaize
archangel
archangel's
archangels
archbishop
archdiocese
archdioceses
archenemy
archeological
archeologist
archeology
archery
archetype
archfool
archipelago
archipelagoes
architect
architect's
architects
architectonic
architectural
architecturally
architecture
architecture's
architectures
archival
archive
archived
archiver
archivers
archiving
archives
archivist
arclike
arctic
ardent
ardently
ardor
arduous
arduousness
arduously
are
area
area's
areas
aren't
arena
arena's
arenas
Argentina
argo
argos
argon
argonaut
argonauts
argot
arguable
arguably
argue
argued
arguer
arguers
arguing
argues
argument
argument's
arguments
argumentation
argumentative
Arianism
Arianist
Arianists
arid
aridity
aries
aright
arise
ariser
arising
arisings
arises
arisen
aristocracy
aristocrat
aristocrat's
aristocrats
aristocratic
aristocratically
aristotelian
aristotle
arithmetic
arithmetics
arithmetical
arithmetically
arithmetize
arithmetized
arithmetizes
Arizona
ark
Arkansas
arm
armed
armer
armers
arming
arms
armadillo
armadillos
armageddon
armament
armament's
armaments
armchair
armchair's
armchairs
Armenian
armful
armhole
armistice
armload
armor
armored
armorer
armory
armour
armpit
armpit's
armpits
armstrong
army
army's
armies
aroma
aromas
aromatic
arose
around
arousal
arouse
aroused
arousing
arouses
arpeggio
arpeggio's
arpeggios
arrack
arraign
arraigned
arraigning
arraigns
arraignment
arraignment's
arraignments
arrange
arranged
arranger
arrangers
arranging
arranges
arrangement
arrangement's
arrangements
arrant
array
arrayed
arrays
arrears
arrest
arrested
arrester
arresters
arresting
arrests
arrestingly
arrestor
arrestor's
arrestors
arrival
arrival's
arrivals
arrive
arrived
arriving
arrives
arrogance
arrogant
arrogantly
arrogate
arrogated
arrogating
arrogation
arrogates
arrow
arrowed
arrows
arrowhead
arrowhead's
arrowheads
arroyo
arroyos
arsenal
arsenal's
arsenals
arsenic
arsine
arson
art
art's
arts
Artemis
arterial
arteriolar
arteriole
arteriole's
arterioles
arteriosclerosis
artery
artery's
arteries
artful
artfulness
artfully
arthogram
arthritis
arthropod
arthropod's
arthropods
artichoke
artichoke's
artichokes
article
article's
articles
articulate
articulateness
articulated
articulating
articulation
articulations
articulately
articulates
articulator
articulators
articulatory
artifact
artifact's
artifacts
artifactually
artifice
artificer
artifices
artificial
artificialness
artificially
artificiality
artificialities
artillerist
artillery
artisan
artisan's
artisans
artist
artist's
artists
artistic
artistically
artistry
artless
artwork
Aryan
as
asbestos
ascend
ascended
ascender
ascenders
ascending
ascends
ascendancy
ascendant
ascendency
ascendent
ascension
ascensions
ascent
ascertain
ascertained
ascertaining
ascertains
ascertainable
ascetic
ascetic's
ascetics
asceticism
ascii
ascot
ascribable
ascribe
ascribed
ascribing
ascribes
ascription
aseptic
ash
asher
ashen
ashes
ashamed
ashamedly
ashman
ashore
ashtray
ashtray's
ashtrays
Asia
Asian
Asians
Asiatic
aside
asinine
ask
asked
asker
askers
asking
asks
askance
askew
asleep
asocial
asp
Aspen
asparagus
aspect
aspect's
aspects
aspersion
aspersion's
aspersions
asphalt
asphyxia
aspic
aspirant
aspirant's
aspirants
aspirate
aspirated
aspirating
aspirates
aspiration
aspiration's
aspirations
aspirator
aspirators
aspire
aspired
aspiring
aspires
aspirin
aspirins
ass
ass's
asses
assail
assailed
assailing
assails
assailant
assailant's
assailants
assassin
assassin's
assassins
assassinate
assassinated
assassinating
assassination
assassinations
assassinates
assault
assaulted
assaulting
assaults
assay
assayed
assaying
assemblage
assemblage's
assemblages
assemble
assembled
assembler
assemblers
assembling
assembles
assembly
assembly's
assemblies
assent
assented
assenter
assenting
assents
assert
asserted
asserter
asserters
asserting
assertive
asserts
assertion
assertion's
assertions
assertively
assertiveness
assess
assessed
assessing
assesses
assessment
assessment's
assessments
assessor
assessors
asset
asset's
assets
assiduity
assiduous
assiduously
assign
assigned
assigner
assigners
assigning
assigns
assignable
assignee
assignee's
assignees
assignment
assignment's
assignments
assimilate
assimilated
assimilating
assimilation
assimilations
assimilates
assist
assisted
assisting
assists
assistance
assistances
assistant
assistant's
assistants
assistantship
assistantships
associate
associated
associating
association
associations
associative
associates
associational
associatively
associativity
associator
associator's
associators
assonance
assonant
assort
assorted
assorts
assortment
assortment's
assortments
assuage
assuaged
assuages
assume
assumed
assuming
assumes
assumption
assumption's
assumptions
assurance
assurance's
assurances
assure
assured
assurer
assurers
assuring
assures
assuredly
assuringly
Assyrian
Assyriology
astatine
aster
aster's
asters
asterisk
asterisk's
asterisks
asteroid
asteroid's
asteroids
asteroidal
asthma
astonish
astonished
astonishing
astonishes
astonishingly
astonishment
astound
astounded
astounding
astounds
astral
astray
astride
astringency
astringent
astronaut
astronaut's
astronauts
astronautics
astronomer
astronomer's
astronomers
astronomical
astronomically
astronomy
astrophysical
astrophysics
astute
astuteness
asunder
asylum
asymmetric
asymmetrically
asymmetry
asymptomatically
asymptote
asymptote's
asymptotes
asymptotic
asymptotically
asynchronism
asynchronous
asynchronously
asynchrony
at
atavistic
ate
atemporal
atheist
atheist's
atheists
atheistic
Athena
Athenian
Athenians
Athens
atherosclerosis
athlete
athlete's
athletes
athletic
athletics
athleticism
Atlantic
atlas
atmosphere
atmosphere's
atmospheres
atmospheric
atoll
atoll's
atolls
atom
atom's
atoms
atomic
atomics
atomically
atomization
atomize
atomized
atomizing
atomizes
atonal
atonally
atone
atoned
atones
atonement
atop
atrocious
atrociously
atrocity
atrocity's
atrocities
atrophic
atrophy
atrophied
atrophying
atrophies
attach
attache
attached
attacher
attachers
attaching
attaches
attachment
attachment's
attachments
attack
attacked
attacker
attackers
attacking
attacks
attackable
attain
attained
attainer
attainers
attaining
attains
attainable
attainably
attainment
attainment's
attainments
attempt
attempted
attempter
attempters
attempting
attempts
attend
attended
attender
attenders
attending
attends
attendance
attendance's
attendances
attendant
attendant's
attendants
attendee
attendee's
attendees
attention
attention's
attentions
attentional
attentionality
attentive
attentiveness
attentively
attenuate
attenuated
attenuating
attenuation
attenuates
attenuator
attenuator's
attenuators
attest
attested
attesting
attests
attic
attic's
attics
attire
attired
attiring
attires
attitude
attitude's
attitudes
attitudinal
attorney
attorney's
attorneys
attract
attracted
attracting
attractive
attracts
attraction
attraction's
attractions
attractively
attractiveness
attractor
attractor's
attractors
attributable
attribute
attributed
attributing
attribution
attributions
attributive
attributes
attributively
attrition
attune
attuned
attuning
attunes
atypical
atypically
auburn
Auckland
auction
auctioneer
auctioneer's
auctioneers
audacious
audaciousness
audaciously
audacity
audible
audibly
audience
audience's
audiences
audio
audiogram
audiogram's
audiograms
audiological
audiologist
audiologist's
audiologists
audiology
audiometer
audiometers
audiometric
audiometry
audit
audited
auditing
audits
audition
auditioned
audition's
auditioning
auditions
auditor
auditor's
auditors
auditorium
auditory
audubon
auger
auger's
augers
aught
augment
augmented
augmenting
augments
augmentation
augur
augurs
August
augustness
augustly
augusta
aunt
aunt's
aunts
aura
aura's
auras
aural
aurally
aureole
aureomycin
aurora
auscultate
auscultated
auscultating
auscultation
auscultations
auscultates
auspice
auspices
auspicious
auspiciously
austere
austerely
austerity
Austin
Australia
Australian
Austria
Austrian
authentic
authentically
authenticate
authenticated
authenticating
authentication
authentications
authenticates
authenticator
authenticators
authenticity
author
authored
author's
authoring
authors
authoritarian
authoritarianism
authoritative
authoritatively
authority
authority's
authorities
authorization
authorization's
authorizations
authorize
authorized
authorizer
authorizers
authorizing
authorizes
authorship
autism
autistic
auto
auto's
autos
autobiographic
autobiographical
autobiography
autobiography's
autobiographies
autocollimator
autocorrelate
autocorrelation
autocracy
autocracies
autocrat
autocrat's
autocrats
autocratic
autocratically
autofluorescence
autograph
autographed
autographing
autographs
automata
automate
automated
automating
automation
automates
automatic
automatically
automaton
automobile
automobile's
automobiles
automotive
autonavigator
autonavigator's
autonavigators
autonomic
autonomous
autonomously
autonomy
autopilot
autopilot's
autopilots
autopsy
autopsied
autopsies
autoregressive
autosuggestibility
autotransformer
autumn
autumn's
autumns
autumnal
auxiliary
auxiliaries
avail
availed
availer
availers
availing
avails
availability
availabilities
available
availably
avalanche
avalanched
avalanching
avalanches
avant
avarice
avaricious
avariciously
ave
avenge
avenged
avenger
avenging
avenges
avenue
avenue's
avenues
aver
avers
average
averaged
averaging
averages
averred
averrer
averring
averse
aversion
aversion
aversion's
aversions
avert
averted
averting
averts
avian
aviary
aviaries
aviation
aviator
aviator's
aviators
avid
avidly
avidity
avionic
avionics
avocado
avocados
avocation
avocation's
avocations
avoid
avoided
avoider
avoiders
avoiding
avoids
avoidable
avoidably
avoidance
avouch
avow
avowed
avows
await
awaited
awaiting
awaits
awake
awaking
awakes
awaken
awakened
awakening
awakens
award
awarded
awarder
awarders
awarding
awards
aware
awareness
awash
away
awe
awed
awesome
awful
awfulness
awfully
awhile
awkward
awkwardness
awkwardly
awl
awl's
awls
awning
awning's
awnings
awoke
awry
ax
axed
axer
axers
axing
axes
axial
axially
axiological
axiom
axiom's
axioms
axiomatic
axiomatically
axiomatization
axiomatization's
axiomatizations
axiomatize
axiomatized
axiomatizing
axiomatizes
axis
axle
axle's
axles
axolotl
axolotl's
axolotls
axon
axon's
axons
aye
ayes
azalea
azalea's
azaleas
azimuth
azimuth's
azimuths
azure
babble
babbled
babbling
babbles
babe
babe's
babes
babel
babel's
baby
babied
babying
babies
babyhood
babyish
baccalaureate
bach
bach's
bachelor
bachelor's
bachelors
bacilli
bacillus
back
backed
backer
backers
backing
backs
backache
backache's
backaches
backarrow
backarrows
backbend
backbend's
backbends
backbone
backbone's
backbones
backdrop
backdrop's
backdrops
background
background's
backgrounds
backlash
backlog
backlog's
backlogs
backpack
backpack's
backpacks
backplane
backplane's
backplanes
backpointer
backpointer's
backpointers
backscatter
backscattered
backscattering
backscatters
backslash
backslashes
backspace
backspaced
backspaces
backstage
backstairs
backstitch
backstitched
backstitching
backstitches
backtrack
backtracked
backtracker
backtrackers
backtracking
backtracks
backup
backups
backward
backwardness
backwards
backwater
backwater's
backwaters
backwoods
backyard
backyard's
backyards
bacon
bacteria
bacterial
bacterium
bad
badness
badly
bade
badge
badger
badgers
badges
badger's
badgered
badgering
badlands
badminton
baffle
baffled
baffler
bafflers
baffling
bag
bag's
bags
bagatelle
bagatelle's
bagatelles
bagel
bagel's
bagels
baggage
bagged
bagger
bagger's
baggers
bagging
baggy
bagpipe
bagpipe's
bagpipes
bah
bail
bailing
bailiff
bailiff's
bailiffs
bait
baited
baiter
baiting
baits
bake
baked
baker
bakers
baking
bakes
bakery
bakery's
bakeries
baklava
balalaika
balalaika's
balalaikas
balance
balanced
balancer
balancers
balancing
balances
balcony
balcony's
balconies
bald
baldness
balding
baldly
bale
baler
bales
baleful
balk
balked
balking
balks
balkan
balkans
balkanize
balkanized
balkanizing
balky
balkiness
ball
balled
baller
ballers
balling
balls
ballad
ballad's
ballads
ballast
ballast's
ballasts
ballerina
ballerina's
ballerinas
ballet
ballet's
ballets
ballgown
ballgown's
ballgowns
ballistic
ballistics
balloon
ballooned
ballooner
ballooners
ballooning
balloons
ballot
ballot's
ballots
ballpark
ballpark's
ballparks
ballplayer
ballplayer's
ballplayers
ballroom
ballroom's
ballrooms
ballyhoo
balm
balm's
balms
balmy
balsa
balsam
Baltic
balustrade
balustrade's
balustrades
bamboo
ban
ban's
bans
banal
banally
banana
banana's
bananas
band
banded
banding
bands
bandage
bandaged
bandaging
bandages
bandit
bandit's
bandits
bandlimit
bandlimited
bandlimiting
bandlimits
bandpass
bandstand
bandstand's
bandstands
bandwagon
bandwagon's
bandwagons
bandwidth
bandwidths
bandy
bandied
bandying
bandies
bane
baneful
bang
banged
banging
bangs
Bangladesh
bangle
bangle's
bangles
banish
banished
banishing
banishes
banishment
banister
banister's
banisters
banjo
banjo's
banjos
bank
banked
banker
bankers
banking
banks
bankrupt
bankrupted
bankrupting
bankrupts
bankruptcy
bankruptcy's
bankruptcies
banned
banner
banner's
banners
banning
banquet
banqueting
banquetings
banquets
banshee
banshee's
banshees
bantam
banter
bantered
bantering
banters
Bantu
bantus
baptism
baptism's
baptisms
baptismal
Baptist
Baptist's
Baptists
baptistery
baptistry
baptistry's
baptistries
baptize
baptized
baptizing
baptizes
bar
bar's
bars
barb
barbed
barber
barbs
Barbados
barbarian
barbarian's
barbarians
barbaric
barbarity
barbarities
barbarous
barbarously
barbecue
barbecued
barbecues
barbecueing
barbell
barbell's
barbells
barbital
barbiturate
barbiturates
bard
bard's
bards
bare
bareness
bared
barest
barer
baring
barely
bares
barefoot
barefooted
barfly
barfly's
barflies
bargain
bargained
bargaining
bargains
barge
barging
barges
baritone
baritone's
baritones
barium
bark
barked
barker
barkers
barking
barks
barley
barn
barn's
barns
barnstorm
barnstormed
barnstorming
barnstorms
barnyard
barnyard's
barnyards
barometer
barometer's
barometers
barometric
baron
baron's
barons
baroness
baronial
barony
barony's
baronies
baroque
baroqueness
barrack
barracks
barrage
barrage's
barrages
barred
barrel
barrel's
barrels
barrelled
barrelling
barren
barrenness
barricade
barricade's
barricades
barrier
barrier's
barriers
barring
barringer
barrow
bartender
bartender's
bartenders
barter
bartered
bartering
barters
bas
basal
basalt
base
baseness
based
baser
basing
basely
bases
baseball
baseball's
baseballs
baseboard
baseboard's
baseboards
baseless
baseline
baseline's
baselines
baseman
basement
basement's
basements
bash
bashed
bashing
bashes
bashful
bashfulness
basic
basics
basically
basil
basin
basin's
basins
basis
bask
basked
basking
basket
basket's
baskets
basketball
basketball's
basketballs
bass
bass's
basses
basset
bassinet
bassinet's
bassinets
basso
bastard
bastard's
bastards
baste
basted
basting
bastion
bastions
bastes
bastion's
bat
bat's
bats
batch
batched
batches
bath
bathe
bathed
bather
bathers
bathing
bathes
bathos
bathrobe
bathrobe's
bathrobes
bathroom
bathroom's
bathrooms
baths
bathtub
bathtub's
bathtubs
baton
baton's
batons
battalion
battalion's
battalions
batted
batten
battens
batter
battered
battering
batters
battery
battery's
batteries
batting
battle
battled
battler
battlers
battling
battles
battlefield
battlefield's
battlefields
battlefront
battlefront's
battlefronts
battleground
battleground's
battlegrounds
battlement
battlement's
battlements
battleship
battleship's
battleships
bauble
bauble's
baubles
baud
bauxite
bawdy
bawl
bawled
bawling
bawls
bay
bayed
baying
bays
bayonet
bayonet's
bayonets
bayou
bayou's
bayous
bazaar
bazaar's
bazaars
be
bed
bing
bely
beach
beached
beaching
beaches
beachhead
beachhead's
beachheads
beacon
beacon's
beacons
bead
beaded
beading
beads
beadle
beadle's
beadles
beady
beagle
beagle's
beagles
beak
beaked
beaker
beakers
beaks
beam
beamed
beamer
beamers
beaming
beams
bean
beaned
beaner
beaners
beaning
beans
bear
bearer
bearers
bearing
bearings
bears
bearable
bearably
beard
bearded
beards
beardless
bearish
beast
beastly
beasts
beat
beater
beaters
beating
beaten
beatings
beats
beatable
beatably
beatific
beatify
beatification
beatitude
beatitude's
beatitudes
beatnik
beatnik's
beatniks
beau
beau's
beaus
beauteous
beauteously
beautiful
beautifully
beautify
beautified
beautifier
beautifiers
beautifying
beautifications
beautifies
beauty
beauty's
beauties
beaver
beaver's
beavers
becalm
becalmed
becalming
becalms
became
because
beck
beckon
beckoned
beckoning
beckons
become
becoming
becomes
becomingly
bed
bed's
beds
bedazzle
bedazzled
bedazzling
bedazzles
bedazzlement
bedbug
bedbug's
bedbugs
bedded
bedder
bedder's
bedders
bedding
bedevil
bedeviled
bedeviling
bedevils
bedfast
bedlam
bedpost
bedpost's
bedposts
bedraggle
bedraggled
bedridden
bedrock
bedrock's
bedroom
bedroom's
bedrooms
bedside
bedspread
bedspread's
bedspreads
bedspring
bedspring's
bedsprings
bedstead
bedstead's
bedsteads
bedtime
bee
beer
beers
being
beings
bees
beech
beecher
beechen
beef
beefed
beefer
beefers
beefing
beefs
beefsteak
beefy
beehive
beehive's
beehives
been
beep
beeps
beet
beet's
beets
Beethoven
beetle
beetled
beetle's
beetling
beetles
befall
befalling
befallen
befalls
befell
befit
befit's
befits
befitted
befitting
befog
befogged
befogging
before
beforehand
befoul
befouled
befouling
befouls
befriend
befriended
befriending
befriends
befuddle
befuddled
befuddling
befuddles
beg
begs
began
beget
begets
begetting
beggar
beggarly
beggars
beggary
begged
begging
begin
begins
beginner
beginner's
beginners
beginning
beginning's
beginnings
begot
begotten
begrudge
begrudged
begrudging
begrudges
begrudgingly
beguile
beguiled
beguiling
beguiles
begun
behalf
behave
behaved
behaving
behaves
behavior
behaviors
behavioral
behaviorally
behaviorism
behavioristic
behead
beheading
beheld
behest
behind
behold
beholder
beholders
beholding
beholden
beholds
behoove
behooves
beige
belabor
belabored
belaboring
belabors
belated
belatedly
belay
belayed
belaying
belays
belch
belched
belching
belches
belfry
belfry's
belfries
Belgian
Belgian's
Belgians
Belgium
belie
belied
belies
belief
belief's
beliefs
believable
believably
believe
believed
believer
believers
believing
believes
belittle
belittled
belittling
belittles
bell
bell's
bells
bellboy
bellboy's
bellboys
belle
belle's
belles
bellhop
bellhop's
bellhops
bellicose
bellicosity
belligerence
belligerent
belligerent's
belligerently
belligerents
bellman
bellmen
bellow
bellowed
bellowing
bellows
bellwether
bellwether's
bellwethers
belly
belly's
bellies
bellyfull
belong
belonged
belonging
belongings
belongs
beloved
below
belt
belted
belting
belts
belying
bemoan
bemoaned
bemoaning
bemoans
bench
benched
benches
benchmark
benchmark's
benchmarks
bend
bender
benders
bending
bends
bendable
beneath
benedict
Benedictine
benediction
benediction's
benedictions
benefactor
benefactor's
benefactors
beneficence
beneficences
beneficial
beneficially
beneficiary
beneficiaries
benefit
benefited
benefiting
benefits
benefitted
benefitting
benevolence
benevolent
Bengal
Bengali
benighted
benign
benignly
bent
Benzedrine
benzene
bequeath
bequeathed
bequeathing
bequeathal
bequeaths
bequest
bequest's
bequests
berate
berated
berating
berates
bereave
bereaved
bereaving
bereaves
bereavement
bereavements
bereft
beret
beret's
berets
beribboned
beriberi
berkelium
Berlin
Berliner
Berliners
Bermuda
berry
berry's
berries
berth
berths
beryl
beryllium
beseech
beseeching
beseeches
beset
besets
besetting
beside
besides
besiege
besieged
besieger
besiegers
besieging
besmirch
besmirched
besmirching
besmirches
besotted
besotter
besotting
besought
bespeak
bespeaks
bespectacled
bessel
best
bested
besting
bests
bestial
bestow
bestowed
bestowal
bestseller
bestseller's
bestsellers
bestselling
bet
bet's
bets
beta
betide
betray
betrayed
betrayer
betraying
betrays
betrayal
betroth
betrothed
betrothal
better
bettered
bettering
betters
betterment
betterments
betting
between
betwixt
bevel
beveled
beveling
bevels
beverage
beverage's
beverages
bevy
bewail
bewailed
bewailing
bewails
beware
bewhiskered
bewilder
bewildered
bewildering
bewilders
bewilderingly
bewilderment
bewitch
bewitched
bewitching
bewitches
beyond
biannual
bias
biased
biasing
biases
bib
bib's
bibs
bibbed
bibbing
bible
bible's
bibles
biblical
biblically
bibliographic
bibliographical
bibliography
bibliography's
bibliographies
bibliophile
bicameral
bicarbonate
bicentennial
bicep
bicep's
biceps
bicker
bickered
bickering
bickers
biconcave
biconvex
bicycle
bicycled
bicycler
bicyclers
bicycling
bicycles
bid
bid's
bids
biddable
bidden
bidder
bidder's
bidders
bidding
biddy
biddies
bide
bidirectional
biennial
biennium
bifocal
bifocals
big
bigness
bigger
biggest
bight
bight's
bights
bigot
bigoted
bigot's
bigots
bigotry
bijection
bijection's
bijections
bijective
bijectively
bike
bike's
biking
bikes
bikini
bikini's
bikinis
bilabial
bilateral
bilaterally
bile
bilge
bilge's
bilges
bilinear
bilingual
bilk
bilked
bilking
bilks
bill
billed
biller
billers
billing
billings
bills
billboard
billboard's
billboards
billet
billeted
billeting
billets
billiard
billiards
billion
billionth
billions
billow
billowed
billows
bimodal
bimolecular
bimonthly
bimonthlies
bin
bin's
bins
binary
binaural
bind
binder
binders
binding
bindings
binds
binge
binges
bingo
binocular
binoculars
binomial
binuclear
biochemical
biochemistry
biofeedback
biographer
biographer's
biographers
biographic
biographical
biographically
biography
biography's
biographies
biological
biologically
biologist
biologist's
biologists
biology
biomedical
biomedicine
biopsy
biopsies
bipartisan
bipartite
biped
bipeds
biplane
biplane's
biplanes
bipolar
biracial
birch
birchen
birches
bird
bird's
birds
birdbath
birdbath's
birdbaths
birdie
birdied
birdies
birdlike
birefringence
birefringent
birth
birthed
birthday
birthday's
birthdays
birthplace
birthplaces
birthright
birthright's
birthrights
births
biscuit
biscuit's
biscuits
bisect
bisected
bisecting
bisects
bisection
bisection's
bisections
bisector
bisector's
bisectors
bishop
bishop's
bishops
bismuth
bison
bison's
bisons
bisque
bisques
bit
bit's
bits
bitch
bitch's
bitches
bite
bited
biter
biters
biting
bites
bitingly
bitten
bitter
bitterness
bitterest
bitterer
bitterly
bitters
bittersweet
bituminous
bitwise
bivalve
bivalve's
bivalves
bivariate
bivouac
bivouacs
biweekly
bizarre
blab
blabs
blabbed
blabbermouth
blabbermouths
blabbing
black
blackness
blacked
blackest
blacker
blacking
blacken
blackens
blackly
blacks
blackberry
blackberry's
blackberries
blackbird
blackbird's
blackbirds
blackboard
blackboard's
blackboards
blackened
blackening
blackjack
blackjack's
blackjacks
blacklist
blacklisted
blacklisting
blacklists
blackmail
blackmailed
blackmailer
blackmailers
blackmailing
blackmails
blackout
blackout's
blackouts
blacksmith
blacksmiths
bladder
bladder's
bladders
blade
blade's
blades
blamable
blame
blamed
blamer
blamers
blaming
blames
blameless
blamelessness
blanch
blanched
blanching
blanches
bland
blandness
blandly
blank
blankness
blanked
blankest
blanker
blanking
blankly
blanks
blanket
blanketed
blanketer
blanketers
blanketing
blankets
blare
blared
blaring
blares
blase
blaspheme
blasphemed
blaspheming
blasphemes
blasphemous
blasphemousness
blasphemously
blasphemy
blasphemies
blast
blasted
blaster
blasters
blasting
blasts
blatant
blatantly
blaze
blazed
blazer
blazers
blazing
blazes
bleach
bleached
bleacher
bleachers
bleaching
bleaches
bleak
bleakness
bleakly
blear
bleary
bleat
bleating
bleats
bled
bleed
bleeder
bleeding
bleedings
bleeds
blemish
blemish's
blemishes
blend
blended
blending
blends
bless
blessed
blessing
blessings
blew
blight
blighted
blimp
blimp's
blimps
blind
blindness
blinded
blinder
blinders
blinding
blindly
blinds
blindfold
blindfolded
blindfolding
blindfolds
blindingly
blink
blinked
blinker
blinkers
blinking
blinks
blip
blip's
blips
bliss
blissful
blissfully
blister
blistered
blistering
blisters
blithe
blithely
blitz
blitz's
blitzes
blitzkrieg
blizzard
blizzard's
blizzards
bloat
bloated
bloater
bloating
bloats
blob
blob's
blobs
bloc
bloc's
blocs
block
blocked
blocker
blockers
blocking
blocks
block's
blockade
blockaded
blockading
blockades
blockage
blockage's
blockages
blockhouse
blockhouses
bloke
bloke's
blokes
blond
blond's
blonds
blonde
blonde's
blondes
blood
blooded
bloods
bloodhound
bloodhound's
bloodhounds
bloodless
bloodshed
bloodshot
bloodstain
bloodstained
bloodstain's
bloodstains
bloodstream
bloody
bloodied
bloodiest
bloom
bloomed
bloomers
blooming
blooms
blossom
blossomed
blossoms
blot
blot's
blots
blotted
blotting
blouse
blouse's
blouses
blow
blower
blowers
blowing
blows
blowfish
blown
blowup
blubber
bludgeon
bludgeoned
bludgeoning
bludgeons
blue
blueness
bluest
bluer
bluing
blues
blueberry
blueberry's
blueberries
bluebird
bluebird's
bluebirds
bluebonnet
bluebonnet's
bluebonnets
bluefish
blueprint
blueprint's
blueprints
bluestocking
bluff
bluffing
bluffs
bluish
blunder
blundered
blundering
blunderings
blunders
blunt
bluntness
blunted
bluntest
blunter
blunting
bluntly
blunts
blur
blur's
blurs
blurb
blurred
blurring
blurry
blurt
blurted
blurting
blurts
blush
blushed
blushing
blushes
bluster
blustered
blustering
blusters
blustery
boar
board
boarded
boarder
boarders
boarding
boards
boardinghouse
boardinghouse's
boardinghouses
boast
boasted
boaster
boasters
boasting
boastings
boasts
boastful
boastfully
boat
boater
boaters
boating
boats
boathouse
boathouse's
boathouses
boatload
boatload's
boatloads
boatman
boatmen
boatsman
boatsmen
boatswain
boatswain's
boatswains
boatyard
boatyard's
boatyards
bob
bob's
bobs
bobbed
bobbin
bobbin's
bobbins
bobbing
bobby
bobolink
bobolink's
bobolinks
bobwhite
bobwhite's
bobwhites
bode
bodes
bodice
bodily
body
bodied
bodies
bodybuilder
bodybuilder's
bodybuilders
bodybuilding
bodyguard
bodyguard's
bodyguards
bodyweight
bog
bog's
bogs
bogged
boggle
boggled
boggling
boggles
bogus
boil
boiled
boiler
boilers
boiling
boils
boilerplate
boisterous
boisterously
bold
boldness
boldest
bolder
boldly
boldface
Bolivia
boll
bologna
Bolshevik
Bolshevik's
Bolsheviks
Bolshevism
bolster
bolstered
bolstering
bolsters
bolt
bolted
bolting
bolts
bomb
bombed
bomber
bombers
bombing
bombings
bombs
bombard
bombarded
bombarding
bombards
bombardment
bombast
bombastic
bombproof
bonanza
bonanza's
bonanzas
bond
bonded
bonder
bonders
bonding
bonds
bondage
bondsman
bondsmen
bone
boned
boner
boners
boning
bones
bonfire
bonfire's
bonfires
bong
bonnet
bonneted
bonnets
bonny
bonus
bonus's
bonuses
bony
boo
booth
boos
boob
booboo
booby
book
booked
booker
bookers
booking
bookings
books
bookcase
bookcase's
bookcases
bookie
bookie's
bookies
bookish
bookkeeper
bookkeeper's
bookkeepers
bookkeeping
booklet
booklet's
booklets
bookseller
bookseller's
booksellers
bookshelf
bookshelf's
bookshelves
bookstore
bookstore's
bookstores
boolean
boom
boomed
booming
booms
boomerang
boomerang's
boomerangs
boomtown
boomtown's
boomtowns
boon
boor
boor's
boors
boorish
boost
boosted
booster
boosting
boosts
boot
booted
booting
boots
booths
bootleg
bootleger
bootlegs
bootlegged
bootlegger
bootlegger's
bootleggers
bootlegging
bootstrap
bootstrap's
bootstraps
bootstrapped
bootstrapping
booty
booze
borate
borates
borax
bordello
bordello's
bordellos
border
bordered
bordering
borderings
borders
borderland
borderland's
borderlands
borderline
bore
bored
borer
boring
bores
boredom
boric
born
borne
borneo
boron
borough
boroughs
borrow
borrowed
borrower
borrowers
borrowing
borrows
bosom
bosom's
bosoms
boss
bossed
bosses
Boston
Bostonian
Bostonian's
Bostonians
bosun
botanical
botanist
botanist's
botanists
botany
botch
botched
botcher
botchers
botching
botches
both
bothers
bother
bothered
bothering
bothers
bothersome
Botswana
bottle
bottled
bottler
bottlers
bottling
bottles
bottleneck
bottleneck's
bottlenecks
bottom
bottomed
bottoming
bottoms
bottomless
botulinus
botulism
bouffant
bough
bough's
boughs
bought
boulder
boulder's
boulders
boulevard
boulevard's
boulevards
bounce
bounced
bouncer
bouncing
bounces
bouncy
bound
bounded
bounding
bounden
bounds
boundary
boundary's
boundaries
boundless
boundlessness
bounteous
bounteously
bounty
bounty's
bounties
bouquet
bouquet's
bouquets
bourbon
bourgeois
bourgeoisie
bout
bout's
bouts
bovine
bovines
bow
bowed
bower
bowers
bowing
bows
bowdlerize
bowdlerized
bowdlerizing
bowdlerizes
bowel
bowel's
bowels
bowl
bowled
bowler
bowlers
bowling
bowls
bowline
bowline's
bowlines
bowman
bowstring
bowstring's
bowstrings
box
boxed
boxer
boxers
boxing
boxes
boxcar
boxcar's
boxcars
boxtop
boxtop's
boxtops
boxwood
boy
boy's
boys
boycott
boycotted
boycotts
boyfriend
boyfriend's
boyfriends
boyhood
boyish
boyishness
bra
bra's
bras
brace
braced
bracing
braces
bracelet
bracelet's
bracelets
bracket
bracketed
bracketing
brackets
brackish
brae
brae's
braes
brag
brags
bragged
bragger
bragging
braid
braided
braiding
braids
braille
brain
brained
braining
brains
brainchild
brainchild's
brainstem
brainstem's
brainstems
brainstorm
brainstorm's
brainstorms
brainwash
brainwashed
brainwashing
brainwashes
brainy
brake
braked
braking
brakes
bramble
bramble's
brambles
brambly
bran
branch
branched
branching
branchings
branches
brand
branded
branding
brands
brandish
brandishing
brandishes
brandy
brash
brashness
brashly
brass
brasses
brassiere
brassy
brat
brat's
brats
bravado
brave
braveness
braved
bravest
braver
braving
bravely
braves
bravery
bravo
bravos
bravura
brawl
brawler
brawling
brawn
bray
brayed
brayer
braying
brays
braze
brazed
brazing
brazes
brazen
brazenness
brazenly
brazier
brazier's
braziers
Brazil
Brazilian
breach
breached
breacher
breachers
breaching
breaches
bread
breaded
breading
breadth
breads
breadboard
breadboard's
breadboards
breadbox
breadbox's
breadboxes
breadwinner
breadwinner's
breadwinners
break
breaker
breakers
breaking
breaks
breakable
breakables
breakage
breakaway
breakdown
breakdown's
breakdowns
breakfast
breakfasted
breakfaster
breakfasters
breakfasting
breakfasts
breakpoint
breakpoint's
breakpoints
breakthrough
breakthrough's
breakthroughes
breakthroughs
breakup
breakwater
breakwater's
breakwaters
breast
breasted
breasts
breastwork
breastwork's
breastworks
breath
breathable
breathe
breathed
breather
breathers
breathing
breathes
breathless
breathlessly
breaths
breathtaking
breathtakingly
breathy
bred
breech
breech's
breeches
breed
breeder
breeding
breeds
breeze
breeze's
breezes
breezily
breezy
bremsstrahlung
brethren
breve
brevet
breveted
breveting
brevets
brevity
brew
brewed
brewer
brewers
brewing
brews
brewery
brewery's
breweries
briar
briar's
briars
bribe
bribed
briber
bribers
bribing
bribes
brick
bricked
bricker
bricks
bricklayer
bricklayer's
bricklayers
bricklaying
bridal
bride
bride's
brides
bridegroom
bridesmaid
bridesmaid's
bridesmaids
bridge
bridged
bridging
bridges
bridgeable
bridgehead
bridgehead's
bridgeheads
bridgework
bridgework's
bridle
bridled
bridling
bridles
brief
briefness
briefed
briefest
briefer
briefly
briefs
briefcase
briefcase's
briefcases
briefing
briefing's
briefings
brier
brig
brig's
brigs
brigade
brigade's
brigades
brigadier
brigadier's
brigadiers
brigantine
bright
brightness
brightest
brighter
brightens
brightly
brighten
brightened
brightener
brighteners
brightening
brightens
brilliance
brilliancy
brilliant
brilliantly
brim
brimful
brimmed
brindle
brindled
brine
bring
bringed
bringer
bringers
bringing
brings
brink
brinkmanship
brisk
briskness
brisker
briskly
bristle
bristled
bristling
bristles
Britain
britches
British
Britisher
Briton
Briton's
Britons
brittle
brittleness
broach
broached
broaching
broaches
broad
broadness
broadest
broader
broadens
broadly
broadband
broadcast
broadcaster
broadcasters
broadcasting
broadcastings
broadcasts
broaden
broadened
broadener
broadeners
broadening
broadenings
broadens
broadside
brocade
brocaded
broccoli
brochure
brochure's
brochures
broil
broiled
broiler
broilers
broiling
broils
broke
broker
brokers
broken
brokenness
brokenly
brokerage
bromide
bromide's
bromides
bromine
bronchi
bronchial
bronchiole
bronchiole's
bronchioles
bronchitis
bronchus
bronze
bronzed
bronzes
brooch
brooch's
brooches
brood
brooder
brooding
broods
brook
brooked
brooks
broom
broom's
brooms
broomstick
broomstick's
broomsticks
broth
brother
brothers
brothel
brothel's
brothels
brother's
brotherhood
brotherly
brotherliness
brought
brow
brow's
brows
browbeat
browbeating
browbeaten
browbeats
brown
brownness
browned
brownest
browner
browning
browns
brownie
brownie's
brownies
brownish
browse
browsing
bruise
bruised
bruising
bruises
brunch
brunches
brunette
brunt
brush
brushed
brushing
brushes
brushfire
brushfire's
brushfires
brushlike
brushy
brusque
brusquely
brutal
brutally
brutality
brutalities
brutalize
brutalized
brutalizing
brutalizes
brute
brute's
brutes
brutish
bubble
bubbled
bubbling
bubbles
bubbly
buck
bucked
bucking
bucks
buckboard
buckboard's
buckboards
bucket
bucket's
buckets
buckle
buckled
buckler
buckling
buckles
buckshot
buckskin
buckskins
buckwheat
bucolic
bud
bud's
buds
budded
budding
buddy
buddy's
buddies
budge
budged
budging
budges
budget
budgeted
budgeter
budgeters
budgeting
budgets
budgetary
buff
buff's
buffs
buffalo
buffaloes
buffer
buffered
buffer's
buffering
buffers
bufferrer
bufferrer's
bufferrers
buffet
buffeted
buffeting
buffetings
buffets
buffoon
buffoon's
buffoons
bug
bug's
bugs
bugged
bugger
bugger's
buggers
bugging
buggy
buggy's
buggies
bugle
bugled
bugler
bugling
bugles
build
builder
builders
building
buildings
builds
buildup
buildup's
buildups
built
bulb
bulb's
bulbs
bulge
bulged
bulging
bulk
bulked
bulks
bulkhead
bulkhead's
bulkheads
bulky
bull
bulled
bulling
bulls
bulldog
bulldog's
bulldogs
bulldoze
bulldozed
bulldozer
bulldozing
bulldozes
bullet
bullet's
bullets
bulletin
bulletin's
bulletins
bullion
bullish
bully
bullied
bullying
bullies
bulwark
bum
bum's
bums
bumble
bumbled
bumbler
bumblers
bumbling
bumbles
bumblebee
bumblebee's
bumblebees
bummed
bumming
bump
bumped
bumper
bumpers
bumping
bumps
bumptious
bumptiousness
bumptiously
bun
bun's
buns
bunch
bunched
bunching
bunches
bundle
bundled
bundling
bundles
bungalow
bungalow's
bungalows
bungle
bungled
bungler
bunglers
bungling
bungles
bunion
bunion's
bunions
bunk
bunker
bunkers
bunks
bunker's
bunkered
bunkhouse
bunkhouse's
bunkhouses
bunkmate
bunkmate's
bunkmates
bunny
bunny's
bunnies
bunt
bunted
bunter
bunters
bunting
bunts
buoy
buoyed
buoys
buoyancy
buoyant
burden
burdened
burdening
burdens
burdensome
bureau
bureau's
bureaus
bureaucracy
bureaucracy's
bureaucracies
bureaucrat
bureaucrat's
bureaucrats
bureaucratic
burgeon
burgeoned
burgeoning
burgess
burgess's
burgesses
burgher
burgher's
burghers
burglar
burglar's
burglars
burglarize
burglarized
burglarizing
burglarizes
burglarproof
burglarproofed
burglarproofing
burglarproofs
burglary
burglary's
burglaries
burial
burl
burlesque
burlesques
burly
burn
burned
burner
burners
burning
burnings
burns
burningly
burnish
burnished
burnishing
burnishes
burnt
burntness
burntly
burp
burped
burping
burps
burr
burr's
burrs
burro
burro's
burros
burrow
burrowed
burrower
burrowing
burrows
bursa
bursitis
burst
bursting
bursts
bury
buried
burying
buries
bus
bused
busing
buses
busboy
busboy's
busboys
bush
bushing
bushes
bushel
bushel's
bushels
bushwhack
bushwhacked
bushwhacking
bushwhacks
bushy
busily
business
business's
businesses
businesslike
businessman
businessmen
buss
bussed
bussing
busses
bust
busted
buster
busts
bustard
bustard's
bustards
bustle
bustling
busy
busied
busiest
busier
but
butane
butcher
butchered
butchers
butchery
butler
butler's
butlers
butt
butt's
butts
butte
butted
butters
butting
buttes
butter
buttered
butterer
butterers
buttering
butterfat
butterfly
butterfly's
butterflies
butternut
buttock
buttock's
buttocks
button
buttoned
buttoning
buttons
buttonhole
buttonhole's
buttonholes
buttress
buttressed
buttressing
buttresses
butyl
butyrate
buxom
buy
buying
buys
buyer
buyer's
buyers
buzz
buzzed
buzzer
buzzing
buzzes
buzzard
buzzard's
buzzards
buzzword
buzzword's
buzzwords
buzzy
by
bier
bye
bygone
bylaw
bylaw's
bylaws
byline
byline's
bylines
bypass
bypassed
bypassing
bypasses
byproduct
byproduct's
byproducts
bystander
bystander's
bystanders
byte
byte's
bytes
byway
byways
byword
byword's
bywords
cab
cab's
cabs
cabbage
cabbage's
cabbages
cabin
cabin's
cabins
cabinet
cabinet's
cabinets
cable
cabled
cabling
cables
cache
cache's
caches
cackle
cackled
cackler
cackling
cackles
cacti
cactus
cadence
cadenced
cafe
cafe's
cafes
cage
caged
cager
cagers
caging
cages
cajole
cajoled
cajoling
cajoles
cake
caked
caking
cakes
calamity
calamity's
calamities
calcium
calculate
calculated
calculating
calculation
calculations
calculative
calculates
calculator
calculator's
calculators
calculus
calendar
calendar's
calendars
calf
caliber
calibers
calibrate
calibrated
calibrating
calibration
calibrations
calibrates
calico
California
caliph
caliphs
call
called
caller
callers
calling
calls
callous
callousness
calloused
callously
calm
calmness
calmed
calmest
calmer
calming
calmly
calms
calmingly
calorie
calorie's
calories
calves
Cambridge
came
camel
camel's
camels
camera
camera's
cameras
camouflage
camouflaged
camouflaging
camouflages
camp
camped
camper
campers
camping
camps
campaign
campaigned
campaigner
campaigners
campaigning
campaigns
campus
campus's
campuses
campusses
can
can's
cans
can't
Canada
canal
canal's
canals
canary
canary's
canaries
cancel
canceled
canceling
cancels
cancellation
cancellation's
cancellations
cancer
cancer's
cancers
candid
candidness
candidly
candidate
candidate's
candidates
candle
candler
candles
candlestick
candlestick's
candlesticks
candor
candy
candied
candies
cane
caner
canker
canned
canner
canner's
canners
cannibal
cannibal's
cannibals
cannibalize
cannibalized
cannibalizing
cannibalizes
canning
cannister
cannister's
cannisters
cannon
cannon's
cannons
cannot
canoe
canoe's
canoes
canon
canon's
canons
canonical
canonically
canonicals
canonicalization
canonicalize
canonicalized
canonicalizing
canonicalizes
canopy
cantankerous
cantankerously
canto
canton
canton's
cantons
cantor
cantor's
cantors
canvas
canvas's
canvases
canvass
canvassed
canvasser
canvassers
canvassing
canvasses
canyon
canyon's
canyons
cap
cap's
caps
capability
capability's
capabilities
capable
capably
capacious
capaciousness
capaciously
capacitance
capacitances
capacitive
capacitor
capacitor's
capacitors
capacity
capacities
cape
caper
capers
capes
capillary
capita
capital
capitally
capitals
capitalism
capitalist
capitalist's
capitalists
capitalization
capitalizations
capitalize
capitalized
capitalizer
capitalizers
capitalizing
capitalizes
capitol
capitol's
capitols
capped
capping
capricious
capriciousness
capriciously
captain
captained
captaining
captains
caption
caption's
captions
captivate
captivated
captivating
captivation
captivates
captive
captive's
captives
captivity
captor
captor's
captors
capture
captured
capturer
capturers
capturing
captures
car
car's
cars
caravan
caravan's
caravans
carbohydrate
carbolic
carbon
carbon's
carbons
carbonate
carbonation
carbonates
carbonic
carbonization
carbonize
carbonized
carbonizer
carbonizers
carbonizing
carbonizes
carcass
carcass's
carcasses
card
carder
cards
cardboard
cardiac
cardinal
cardinally
cardinals
cardinality
cardinality's
cardinalities
care
cared
caring
cares
career
career's
careers
carefree
careful
carefulness
carefully
careless
carelessness
carelessly
caress
caressed
caresser
caressing
caresses
caret
cargo
cargoes
caribou
carnival
carnival's
carnivals
carnivorous
carnivorously
carol
carol's
carols
Carolina
Carolina's
Carolinas
carpenter
carpenter's
carpenters
carpet
carpeted
carpeting
carpets
carriage
carriage's
carriages
carrot
carrot's
carrots
carry
carried
carrier
carriers
carrying
carries
carryover
carryovers
cart
carted
carter
carters
carting
carts
cartesian
cartography
carton
carton's
cartons
cartoon
cartoon's
cartoons
cartridge
cartridge's
cartridges
carve
carved
carver
carving
carvings
carves
cascade
cascaded
cascading
cascades
case
cased
casing
casings
cases
casement
casement's
casements
cash
cashed
casher
cashers
cashing
cashes
cashier
cashier's
cashiers
cask
cask's
casks
casket
casket's
caskets
casserole
casserole's
casseroles
cast
cast's
casts
caste
casted
caster
casters
casting
castes
castle
castled
castles
casual
casualness
casually
casuals
casualty
casualty's
casualties
cat
cat's
cats
catalog
cataloged
cataloger
cataloging
catalogs
catalogue
catalogued
catalogues
catalyst
catalyst's
catalysts
cataract
catastrophe
catastrophic
catch
catched
catcher
catchers
catching
catches
catchable
categorical
categorically
categorization
categorize
categorized
categorizer
categorizers
categorizing
categorizes
category
category's
categories
cater
catered
caterer
catering
caters
caterpillar
caterpillar's
caterpillars
cathedral
cathedral's
cathedrals
catheter
catheters
cathode
cathode's
cathodes
Catholic
Catholic's
Catholics
catsup
cattle
caught
causal
causally
causality
causation
causation's
causations
cause
caused
causer
causing
causes
causeway
causeway's
causeways
caustic
causticly
caustics
caution
cautioned
cautioner
cautioners
cautioning
cautionings
cautions
cautious
cautiousness
cautiously
cavalier
cavalierness
cavalierly
cavalry
cave
caved
caving
caves
caveat
caveat's
caveats
cavern
cavern's
caverns
cavity
cavity's
cavities
caw
cawing
cdr
cease
ceased
ceasing
ceases
ceaseless
ceaselessness
ceaselessly
cedar
ceiling
ceiling's
ceilings
celebrate
celebrated
celebrating
celebration
celebrations
celebrates
celebrity
celebrity's
celebrities
celery
celestial
celestially
cell
celled
cells
cellar
cellar's
cellars
cellist
cellist's
cellists
cellular
cement
cemented
cementing
cements
cemetery
cemetery's
cemeteries
censor
censored
censoring
censors
censorship
censure
censured
censurer
censures
census
census's
censuses
cent
centers
cents
center
centered
centering
centers
centerpiece
centerpiece's
centerpieces
centimeter
centimeters
centipede
centipede's
centipedes
central
centrally
centralization
centralize
centralized
centralizing
centralizes
centripetal
century
century's
centuries
cereal
cereal's
cereals
cerebral
ceremonial
ceremonialness
ceremonially
ceremony
ceremony's
ceremonies
certain
certainly
certainty
certainties
certifiable
certificate
certification
certifications
certificates
certify
certified
certifier
certifiers
certifying
certification
certifies
cessation
cessation's
cessations
chafe
chafer
chafing
chaff
chaffer
chaffing
chagrin
chain
chained
chaining
chains
chair
chaired
chairing
chairs
chairman
chairmen
chairperson
chairperson's
chairpersons
chalice
chalice's
chalices
chalk
chalked
chalking
chalks
challenge
challenged
challenger
challengers
challenging
challenges
chamber
chambered
chambers
chamberlain
chamberlain's
chamberlains
champagne
champaign
champion
championed
championing
champions
championship
championship's
championships
chance
chanced
chancing
chances
chancellor
chandelier
chandelier's
chandeliers
change
changed
changer
changers
changing
changes
changeability
changeable
changeably
channel
channeled
channeling
channels
channelled
channeller
channeller's
channellers
channelling
chant
chanted
chanter
chanting
chants
chanticleer
chanticleer's
chanticleers
chaos
chaotic
chap
chap's
chaps
chapel
chapel's
chapels
chaperon
chaperoned
chaplain
chaplain's
chaplains
chapter
chapter's
chapters
char
chars
character
character's
characters
characteristic
characteristic's
characteristics
characteristically
characterizable
characterization
characterization's
characterizations
characterize
characterized
characterizer
characterizers
characterizing
characterizes
charcoal
charcoaled
charge
charged
charger
chargers
charging
charges
chargeable
chariot
chariot's
chariots
charitable
charitableness
charity
charity's
charities
charm
charmed
charmer
charmers
charming
charms
charmingly
chart
charted
charter
charters
charting
chartings
charts
chartable
chartered
chartering
chase
chased
chaser
chasers
chasing
chases
chasm
chasm's
chasms
chaste
chasteness
chastely
chastise
chastised
chastiser
chastisers
chastising
chastises
chat
chateau
chateau's
chateaus
chatter
chattered
chatterer
chattering
chatters
chattererz
chauffeur
chauffeured
cheap
cheapness
cheapest
cheaper
cheapens
cheaply
cheapen
cheapened
cheapening
cheapens
cheat
cheated
cheater
cheaters
cheating
cheats
check
checked
checker
checkers
checking
checks
checkable
checkbook
checkbook's
checkbooks
checkout
checkpoint
checkpoint's
checkpoints
checksum
checksum's
checksums
cheek
cheek's
cheeks
cheer
cheered
cheerer
cheering
cheers
cheerful
cheerfulness
cheerfully
cheerily
cheerless
cheerlessness
cheerlessly
cheery
cheeriness
cheese
cheese's
cheeses
chef
chef's
chefs
chemical
chemically
chemicals
chemise
chemist
chemist's
chemists
chemistry
chemistries
cherish
cherished
cherishing
cherishes
cherry
cherry's
cherries
cherub
cherub's
cherubs
cherubim
chess
chest
chester
chests
chestnut
chestnut's
chestnuts
chew
chewed
chewer
chewers
chewing
chews
chick
chicken
chickens
chicks
chickadee
chickadee's
chickadees
chide
chided
chiding
chides
chief
chiefly
chiefs
chieftain
chieftain's
chieftains
chiffon
child
childhood
childish
childishness
childishly
children
chill
chilled
chiller
chillers
chilling
chills
chillingly
chilly
chilliness
chillier
chime
chime's
chimes
chimney
chimney's
chimneys
chin
chin's
chins
Chinese
chink
chinked
chinks
chinned
chinner
chinners
chinning
chintz
chip
chip's
chips
chipmunk
chipmunk's
chipmunks
chirp
chirped
chirping
chirps
chisel
chiseled
chiseler
chisels
chivalrous
chivalrousness
chivalrously
chivalry
chlorine
chloroplast
chloroplast's
chloroplasts
chock
chock's
chocks
chocolate
chocolate's
chocolates
choice
choicest
choices
choir
choir's
choirs
choke
choked
choker
chokers
choking
chokes
cholera
choose
chooser
choosers
choosing
chooses
chop
chops
chopped
chopper
chopper's
choppers
chopping
choral
chord
chord's
chords
chore
choring
chores
chorus
chorused
choruses
chose
chosen
christen
christened
christening
christens
Christian
Christian's
Christians
Christmas
chronic
chronicle
chronicled
chronicler
chroniclers
chronicles
chronological
chronologically
chronology
chronology's
chronologies
chubby
chubbiness
chubbiest
chubbier
chuck
chuck's
chucks
chuckle
chuckled
chuckles
chum
chunk
chunk's
chunks
church
churchly
churches
churchman
churchyard
churchyard's
churchyards
churn
churned
churning
churns
chute
chute's
chutes
cider
cigar
cigar's
cigars
cigarette
cigarette's
cigarettes
cinder
cinder's
cinders
cinnamon
cipher
cipher's
ciphers
circle
circled
circling
circles
circuit
circuit's
circuits
circuitous
circuitously
circuitry
circular
circularly
circularity
circulate
circulated
circulating
circulation
circulates
circumference
circumflex
circumlocution
circumlocution's
circumlocutions
circumspect
circumspectly
circumstance
circumstance's
circumstances
circumstantial
circumstantially
circumvent
circumvented
circumventing
circumvents
circumventable
circus
circus's
circuses
cistern
cistern's
cisterns
citadel
citadel's
citadels
citation
citation's
citations
cite
cited
citing
cites
citizen
citizen's
citizens
citizenship
city
city's
cities
civic
civics
civil
civilly
civilian
civilian's
civilians
civility
civilization
civilization's
civilizations
civilize
civilized
civilizing
civilizes
clad
claim
claimed
claiming
claims
claimable
claimant
claimant's
claimants
clairvoyant
clairvoyantly
clam
clam's
clams
clamber
clambered
clambering
clambers
clamor
clamored
clamoring
clamors
clamorous
clamp
clamped
clamping
clamps
clan
clang
clanged
clanging
clangs
clap
claps
clarify
clarified
clarifying
clarification
clarifications
clarifies
clarity
clash
clashed
clashing
clashes
clasp
clasped
clasping
clasps
class
classed
classes
classic
classics
classical
classically
classifiable
classify
classified
classifier
classifiers
classifying
classification
classifications
classifies
classmate
classmate's
classmates
classroom
classroom's
classrooms
clatter
clattered
clattering
clause
clause's
clauses
claw
clawed
clawing
claws
clay
clay's
clays
clean
cleanness
cleaned
cleanest
cleaning
cleanly
cleans
cleaner
cleaner's
cleaners
cleanliness
cleanse
cleansed
cleanser
cleansers
cleansing
cleanses
clear
clearness
cleared
clearest
clearer
clearly
clears
clearance
clearance's
clearances
clearing
clearing's
clearings
cleavage
cleave
cleaved
cleaver
cleavers
cleaving
cleaves
cleft
cleft's
clefts
clench
clenched
clenches
clergy
clergyman
clerical
clerk
clerked
clerking
clerks
clever
cleverness
cleverest
cleverer
cleverly
cliche
cliche's
cliches
click
clicked
clicking
clicks
client
client's
clients
cliff
cliff's
cliffs
climate
climate's
climates
climatic
climatically
climax
climaxed
climaxes
climb
climbed
climber
climbers
climbing
climbs
clime
clime's
climes
clinch
clinched
clincher
clinches
cling
clinging
clings
clinic
clinic's
clinics
clinical
clinically
clink
clinked
clinker
clip
clip's
clips
clipped
clipper
clipper's
clippers
clipping
clipping's
clippings
clique
clique's
cliques
cloak
cloak's
cloaks
clobber
clobbered
clobbering
clobbers
clock
clocked
clocker
clockers
clocking
clockings
clocks
clockwise
clockwork
clod
clod's
clods
clog
clog's
clogs
clogged
clogging
cloister
cloister's
cloisters
clone
cloned
cloning
clones
close
closed
closest
closing
closely
closes
closeness
closenesses
closer
closers
closet
closeted
closets
closure
closure's
closures
cloth
clothe
clothed
clothing
clothes
cloud
clouded
clouding
clouds
cloudless
cloudy
cloudiness
cloudiest
cloudier
clout
clove
clover
cloves
clown
clowning
clowns
club
club's
clubs
clubbed
clubbing
cluck
clucked
clucking
clucks
clue
clue's
clues
clump
clumped
clumping
clumps
clumsily
clumsy
clumsiness
clung
cluster
clustered
clustering
clusterings
clusters
clutch
clutched
clutching
clutches
clutter
cluttered
cluttering
clutters
coach
coached
coacher
coaching
coaches
coachman
coal
coals
coalesce
coalesced
coalescing
coalesces
coalition
coarse
coarseness
coarsest
coarser
coarsely
coarsen
coarsened
coast
coasted
coaster
coasters
coasting
coasts
coastal
coat
coated
coating
coatings
coats
coax
coaxed
coaxer
coaxing
coaxes
cobbler
cobbler's
cobblers
cobol
cobweb
cobweb's
cobwebs
cock
cocked
cocking
cocks
cocktail
cocktail's
cocktails
cocoa
coconut
coconut's
coconuts
cocoon
cocoon's
cocoons
cod
code
coded
coder
coders
coding
codings
codes
codeword
codeword's
codewords
codification
codification's
codifications
codifier
codifier's
codifiers
codify
codified
codifying
codifies
coefficient
coefficient's
coefficients
coerce
coerced
coercing
coercion
coercive
coerces
coexist
coexisted
coexisting
coexists
coexistence
coffee
coffee's
coffees
coffer
coffer's
coffers
coffin
coffin's
coffins
cogent
cogently
cogitate
cogitated
cogitating
cogitation
cogitates
cognition
cognitive
cognitively
cognizance
cognizant
cohabitate
cohabitation
cohabitations
cohere
cohered
cohering
coheres
coherence
coherent
coherently
cohesion
cohesive
cohesiveness
cohesively
coil
coiled
coiling
coils
coin
coined
coiner
coining
coins
coinage
coincide
coincided
coinciding
coincides
coincidence
coincidence's
coincidences
coincidental
coke
cokes
cold
coldness
coldest
colder
coldly
colds
collaborate
collaborated
collaborating
collaboration
collaborations
collaborative
collaborates
collaborator
collaborator's
collaborators
collapse
collapsed
collapsing
collapses
collar
collared
collaring
collars
collateral
colleague
colleague's
colleagues
collect
collected
collecting
collective
collects
collectible
collection
collection's
collections
collective
collectively
collectives
collector
collector's
collectors
college
college's
colleges
collegiate
collide
collided
colliding
collides
collie
collier
collies
collision
collision's
collisions
cologne
colon
colon's
colons
colonel
colonel's
colonels
colonial
colonially
colonials
colonist
colonist's
colonists
colonization
colonize
colonized
colonizer
colonizers
colonizing
colonizes
colony
colony's
colonies
color
colored
colorer
colorers
coloring
colorings
colors
Colorado
colorful
colorless
colossal
colt
colt's
colts
column
column's
columns
columnate
columnated
columnating
columnation
columnates
columnize
columnized
columnizing
columnizes
comb
combed
comber
combers
combing
combings
combs
combat
combated
combating
combative
combats
combatant
combatant's
combatants
combination
combination's
combinations
combinational
combinator
combinator's
combinators
combinatorial
combinatorially
combinatoric
combinatorics
combine
combined
combining
combines
combustion
come
comer
comers
coming
comely
comings
comes
comedian
comedian's
comedians
comedic
comedy
comedy's
comedies
comeliness
comestible
comet
comet's
comets
comfort
comforted
comforter
comforters
comforting
comforts
comfortability
comfortabilities
comfortable
comfortably
comfortingly
comic
comic's
comics
comical
comically
comma
comma's
commas
command
commanded
commander
commanders
commanding
commands
command's
commandant
commandant's
commandants
commandingly
commandment
commandment's
commandments
commemorate
commemorated
commemorating
commemoration
commemorative
commemorates
commence
commenced
commencing
commences
commencement
commencement's
commencements
commend
commended
commending
commends
commendation
commendation's
commendations
commensurate
comment
commented
commenting
comments
commentary
commentary's
commentaries
commentator
commentator's
commentators
commerce
commercial
commercialness
commercially
commercials
commission
commissioned
commissioner
commissioners
commissioning
commissions
commit
commits
commitment
commitment's
commitments
committed
committee
committee's
committees
committing
commodity
commodity's
commodities
commodore
commodore's
commodores
common
commonness
commonest
commonly
commons
commonality
commonalities
commoner
commoner's
commoners
commonplace
commonplaces
commonwealth
commonwealths
commotion
communal
communally
commune
communion
communes
communicant
communicant's
communicants
communicate
communicated
communicating
communication
communications
communicative
communicates
communicator
communicator's
communicators
communist
communist's
communists
community
community's
communities
commutative
commutativity
commute
commuted
commuter
commuters
commuting
commutes
compact
compactness
compacted
compactest
compacter
compacting
compactly
compacts
compactor
compactor's
compactors
companion
companion's
companions
companionable
companionship
company
company's
companies
comparability
comparable
comparably
comparative
comparatively
comparatives
comparator
comparator's
comparators
compare
compared
comparing
compares
comparison
comparison's
comparisons
compartment
compartmented
compartments
compartmentalize
compartmentalized
compartmentalizing
compartmentalizes
compass
compassion
compassionate
compassionately
compatibility
compatibility's
compatibilities
compatible
compatibly
compel
compels
compelled
compelling
compellingly
compendium
compensate
compensated
compensating
compensation
compensations
compensates
compensatory
compete
competed
competing
competes
competence
competent
competently
competition
competition's
competitions
competitive
competitively
competitor
competitor's
competitors
compilation
compilation's
compilations
compile
compiled
compiler
compilers
compiling
compiles
compiler's
complain
complained
complainer
complainers
complaining
complains
complaint
complaint's
complaints
complement
complemented
complementer
complementers
complementing
complements
complementary
complete
completeness
completed
completing
completion
completions
completely
completes
complex
complexly
complexes
complexion
complexity
complexities
compliance
complicate
complicated
complicating
complication
complications
complicates
complicator
complicator's
complicators
complicity
compliment
complimented
complimenter
complimenters
complimenting
compliments
complimentary
comply
complied
complying
component
component's
components
componentwise
compose
composed
composer
composers
composing
composes
composedly
composite
composition
compositions
composites
compositional
composure
compound
compounded
compounding
compounds
comprehend
comprehended
comprehending
comprehends
comprehensibility
comprehensible
comprehension
comprehensive
comprehensively
compress
compressed
compressing
compressive
compresses
compressible
compression
comprise
comprised
comprising
comprises
compromise
compromised
compromiser
compromisers
compromising
compromises
compromising
compromisingly
comptroller
comptroller's
comptrollers
compulsion
compulsion's
compulsions
compulsory
compunction
computability
computable
computation
computation's
computations
computational
computationally
compute
computed
computer
computers
computing
computes
computer's
computerize
computerized
computerizing
computerizes
comrade
comradely
comrades
comradeship
concatenate
concatenated
concatenating
concatenation
concatenations
concatenates
conceal
concealed
concealer
concealers
concealing
conceals
concealment
concede
conceded
conceding
concedes
conceit
conceited
conceits
conceivable
conceivably
conceive
conceived
conceiving
conceives
concentrate
concentrated
concentrating
concentration
concentrations
concentrates
concentrator
concentrators
concentric
concept
concept's
concepts
conception
conception's
conceptions
conceptual
conceptually
conceptualization
conceptualization's
conceptualizations
conceptualize
conceptualized
conceptualizing
conceptualizes
concern
concerned
concerning
concerns
concernedly
concert
concerted
concerts
concession
concession's
concessions
concise
conciseness
concisely
conclude
concluded
concluding
concludes
conclusion
conclusion's
conclusions
conclusive
conclusively
concomitant
concord
concrete
concreteness
concretion
concretely
concretes
concur
concurs
concurred
concurrence
concurrency
concurrencies
concurrent
concurrently
concurring
condemn
condemned
condemner
condemners
condemning
condemns
condemnation
condemnations
condensation
condense
condensed
condenser
condensing
condenses
condescend
condescending
condition
conditioned
conditioner
conditioners
conditioning
conditions
conditional
conditionally
conditionals
condone
condoned
condoning
condones
conducive
conduct
conducted
conducting
conductive
conducts
conduction
conductivity
conductor
conductor's
conductors
cone
cone's
cones
confederacy
confederate
confederation
confederations
confederates
confer
confers
conference
conference's
conferences
conferred
conferrer
conferrer's
conferrers
conferring
confess
confessed
confessing
confesses
confession
confession's
confessions
confessor
confessor's
confessors
confidant
confidant's
confidants
confide
confided
confiding
confides
confidence
confidences
confident
confidently
confidential
confidentially
confidentiality
confidingly
configurable
configuration
configuration's
configurations
configure
configured
configuring
configures
confine
confined
confiner
confining
confines
confinement
confinement's
confinements
confirm
confirmed
confirming
confirms
confirmation
confirmation's
confirmations
confiscate
confiscated
confiscating
confiscation
confiscations
confiscates
conflict
conflicted
conflicting
conflicts
conform
conformed
conforming
conforms
conformity
confound
confounded
confounding
confounds
confront
confronted
confronter
confronters
confronting
confronts
confrontation
confrontation's
confrontations
confuse
confused
confuser
confusers
confusing
confusion
confusions
confuses
confusingly
congenial
congenially
congested
congestion
congratulate
congratulated
congratulation
congratulations
congregate
congregated
congregating
congregation
congregations
congregates
congress
congress's
congresses
congressional
congressionally
congressman
congruence
congruent
conjecture
conjectured
conjecturing
conjectures
conjoined
conjunct
conjuncted
conjunctive
conjuncts
conjunction
conjunction's
conjunctions
conjunctively
conjure
conjured
conjurer
conjuring
conjures
connect
connected
connecting
connects
connectedness
connection
connection's
connections
connective
connective's
connectives
connectivity
connector
connector's
connectors
connoisseur
connoisseur's
connoisseurs
connote
connoted
connoting
connotes
conquer
conquered
conquerer
conquerers
conquering
conquers
conquerable
conqueror
conqueror's
conquerors
conquest
conquest's
conquests
cons
conscience
conscience's
consciences
conscientious
conscientiously
conscious
consciousness
consciously
consecrate
consecration
consecutive
consecutively
consensus
consent
consented
consenter
consenters
consenting
consents
consequence
consequence's
consequences
consequent
consequently
consequents
consequential
consequentiality
consequentialities
conservation
conservation's
conservations
conservationist
conservationist's
conservationists
conservatism
conservative
conservatively
conservatives
conserve
conserved
conserving
conserves
consider
considered
considering
considers
considerable
considerably
considerate
consideration
considerations
considerately
consign
consigned
consigning
consigns
consist
consisted
consisting
consists
consistency
consistent
consistently
consolable
consolation
consolation's
consolations
console
consoled
consoler
consolers
consoling
consoles
consolidate
consolidated
consolidating
consolidation
consolidates
consolingly
consonant
consonant's
consonants
consort
consorted
consorting
consorts
consortium
conspicuous
conspicuously
conspiracy
conspiracy's
conspiracies
conspirator
conspirator's
conspirators
conspire
conspired
conspires
constable
constable's
constables
constancy
constant
constantly
constants
constellation
constellation's
constellations
consternation
constituency
constituency's
constituencies
constituent
constituent's
constituents
constitute
constituted
constituting
constitution
constitutions
constitutive
constitutes
constitutional
constitutionally
constitutionality
constrain
constrained
constraining
constrains
constraint
constraint's
constraints
construct
constructed
constructing
constructive
constructs
constructibility
constructible
construction
construction's
constructions
constructively
constructor
constructor's
constructors
construe
construed
construing
consul
consul's
consuls
consulate
consulate's
consulates
consult
consulted
consulting
consults
consultant
consultant's
consultants
consultation
consultation's
consultations
consumable
consume
consumed
consumer
consumers
consuming
consumes
consumer's
consummate
consummated
consummation
consummately
consumption
consumption's
consumptions
consumptive
consumptively
contact
contacted
contacting
contacts
contagion
contagious
contagiously
contain
contained
container
containers
containing
contains
containable
containment
containment's
containments
contaminate
contaminated
contaminating
contamination
contaminates
contemplate
contemplated
contemplating
contemplation
contemplations
contemplative
contemplates
contemporary
contemporariness
contemporaries
contempt
contemptible
contemptuous
contemptuously
contend
contended
contender
contenders
contending
contends
content
contented
contenting
contently
contents
contention
contention's
contentions
contentment
contest
contested
contester
contesters
contesting
contests
contestable
context
context's
contexts
contextual
contextually
contiguity
contiguous
contiguously
continent
continent's
continents
continental
continentally
contingency
contingency's
contingencies
contingent
contingent's
contingents
continual
continually
continuance
continuance's
continuances
continuation
continuation's
continuations
continue
continued
continuing
continues
continuity
continuities
continuous
continuously
continuum
contour
contoured
contour's
contouring
contours
contract
contracted
contracting
contracts
contraction
contraction's
contractions
contractor
contractor's
contractors
contractual
contractually
contradict
contradicted
contradicting
contradicts
contradiction
contradiction's
contradictions
contradictory
contradistinction
contradistinctions
contrapositive
contrapositives
contraption
contraption's
contraptions
contrary
contrariness
contrast
contrasted
contraster
contrasters
contrasting
contrasts
contrastingly
contribute
contributed
contributing
contribution
contributions
contributes
contributor
contributor's
contributors
contributorily
contributory
contrivance
contrivance's
contrivances
contrive
contrived
contriver
contriving
contrives
control
control's
controls
controllability
controllable
controllably
controlled
controller
controller's
controllers
controlling
controversial
controversy
controversy's
controversies
conundrum
conundrum's
conundrums
convene
convened
convening
convenes
convenience
convenience's
conveniences
convenient
conveniently
convent
convent's
convents
convention
convention's
conventions
conventional
conventionally
converge
converged
converging
converges
convergence
convergent
conversant
conversantly
conversation
conversation's
conversations
conversational
conversationally
converse
conversed
conversing
conversion
conversions
conversely
converses
convert
converted
converter
converters
converting
converts
convertibility
convertible
convex
convey
conveyed
conveyer
conveyers
conveying
conveys
conveyance
conveyance's
conveyances
convict
convicted
convicting
convicts
conviction
conviction's
convictions
convince
convinced
convincer
convincers
convincing
convinces
convincingly
convoluted
convoy
convoyed
convoying
convoys
convulsion
convulsion's
convulsions
coo
cooing
cook
cooked
cooking
cooks
cookery
cookie
cookie's
cookies
cooky
cool
coolness
cooled
coolest
cooling
coolly
cools
cooler
cooler's
coolers
coolie
coolie's
coolies
coon
coon's
coons
coop
cooped
cooper
coopers
coops
cooperate
cooperated
cooperating
cooperation
cooperations
cooperative
cooperates
cooperatively
cooperatives
cooperator
cooperator's
cooperators
coordinate
coordinated
coordinating
coordination
coordinations
coordinates
coordinator
coordinator's
coordinators
cop
cop's
cops
cope
coped
coping
copings
copes
copious
copiousness
copiously
copper
copper's
coppers
copse
copy
copied
copier
copiers
copying
copies
copyright
copyright's
copyrights
coral
cord
corded
corder
cords
cordial
cordially
core
cored
corer
corers
coring
cores
cork
corked
corker
corkers
corking
corks
cormorant
corn
corner
corners
corning
corns
cornered
cornerstone
cornerstone's
cornerstones
cornfield
cornfield's
cornfields
corollary
corollary's
corollaries
coronary
coronaries
coronation
coronet
coronet's
coronets
coroutine
coroutine's
coroutines
corporacy
corporacies
corporal
corporal's
corporals
corporate
corporation
corporations
corporately
corporation's
corps
corpse
corpse's
corpses
corpus
correct
correctness
corrected
correcting
correctly
corrects
correctable
correction
corrections
corrective
correctively
correctives
corrector
correlate
correlated
correlating
correlation
correlations
correlative
correlates
correspond
corresponded
corresponding
corresponds
correspondence
correspondence's
correspondences
correspondent
correspondent's
correspondents
correspondingly
corridor
corridor's
corridors
corroborate
corroborated
corroborating
corroboration
corroborations
corroborative
corroborates
corrosion
corrupt
corrupted
corrupter
corrupting
corrupts
corruption
corset
cosine
cosines
cosmetic
cosmetics
cosmology
cosmopolitan
cost
costed
costing
costly
costs
costume
costumed
costumer
costuming
costumes
cot
cot's
cots
cottage
cottager
cottages
cotton
cottons
cotyledon
cotyledon's
cotyledons
couch
couched
couching
couches
cough
coughed
coughing
coughs
could
couldn't
council
council's
councils
councillor
councillor's
councillors
counsel
counseled
counseling
counsels
counselled
counselling
counsellor
counsellor's
counsellors
counselor
counselor's
counselors
count
counted
counters
counting
counts
countable
countably
countenance
counter
countered
countering
counters
counteract
counteracted
counteracting
counteractive
counterclockwise
counterexample
counterexamples
counterfeit
counterfeited
counterfeiter
counterfeiting
countermeasure
countermeasure's
countermeasures
counterpart
counterpart's
counterparts
counterpoint
counterpointing
counterproductive
counterrevolution
countess
countless
country
country's
countries
countryman
countryside
county
county's
counties
couple
coupled
coupler
couplers
coupling
couplings
couples
coupon
coupon's
coupons
courage
courageous
courageously
courier
courier's
couriers
course
coursed
courser
coursing
courses
court
courted
courter
courters
courting
courtly
courts
courteous
courteously
courtesy
courtesy's
courtesies
courthouse
courthouse's
courthouses
courtier
courtier's
courtiers
courtroom
courtroom's
courtrooms
courtship
courtyard
courtyard's
courtyards
cousin
cousin's
cousins
cove
covers
coves
covenant
covenant's
covenants
cover
covered
covering
coverings
covers
coverable
coverage
coverlet
coverlet's
coverlets
covert
covertly
covet
coveted
coveting
covets
covetous
covetousness
cow
cowed
cowers
cowing
cows
coward
cowardly
cowardice
cowboy
cowboy's
cowboys
cower
cowered
cowerer
cowerers
cowering
cowers
coweringly
cowl
cowling
cowls
cowslip
cowslip's
cowslips
coyote
coyote's
coyotes
cozy
coziness
cozier
crab
crab's
crabs
crack
cracked
cracker
crackers
cracking
cracks
crackle
crackled
crackling
crackles
cradle
cradled
cradles
craft
crafted
crafter
crafting
crafts
craftsman
crafty
craftiness
crag
crag's
crags
cram
crams
cramp
cramp's
cramps
cranberry
cranberry's
cranberries
crane
crane's
cranes
crank
cranked
cranking
cranks
crankily
cranky
crankiest
crankier
crash
crashed
crasher
crashers
crashing
crashes
crate
crater
craters
crates
cravat
cravat's
cravats
crave
craved
craving
craves
craven
crawl
crawled
crawler
crawlers
crawling
crawls
craze
crazed
crazing
crazes
crazily
crazy
craziness
craziest
crazier
creak
creaked
creaking
creaks
cream
creamed
creamer
creamers
creaming
creams
creamy
crease
creased
creasing
creases
create
created
creating
creation
creations
creative
creates
creatively
creativeness
creativity
creator
creator's
creators
creature
creature's
creatures
credence
credibility
credible
credibly
credit
credited
crediting
credits
creditable
creditably
creditor
creditor's
creditors
credulity
credulous
credulousness
creed
creed's
creeds
creek
creek's
creeks
creep
creeper
creepers
creeping
creeps
cremate
cremated
cremating
cremation
cremations
cremates
crepe
crept
crescent
crescent's
crescents
crest
crested
crests
crevice
crevice's
crevices
crew
crewed
crewing
crews
crib
crib's
cribs
cricket
cricket's
crickets
crime
crime's
crimes
criminal
criminally
criminals
crimson
crimsoning
cringe
cringed
cringing
cringes
cripple
crippled
crippling
cripples
crises
crisis
crisp
crispness
crisply
criteria
criterion
critic
critic's
critics
critical
critically
criticise
criticised
criticism
criticism's
criticisms
criticize
criticized
criticizing
criticizes
critique
critiquing
critiques
croak
croaked
croaking
croaks
crochet
crochets
crook
crooked
crooks
crop
crop's
crops
cropped
cropper
cropper's
croppers
cropping
cross
crossed
crosser
crossers
crossing
crossly
crossings
crosses
crossable
crossbar
crossbar's
crossbars
crossover
crossover's
crossovers
crossword
crossword's
crosswords
crouch
crouched
crouching
crow
crowed
crowing
crows
crowd
crowded
crowder
crowding
crowds
crown
crowned
crowning
crowns
crucial
crucially
crucify
crucified
crucifying
crucifies
crude
crudeness
crudest
crudely
cruel
cruelest
crueler
cruelly
cruelty
cruise
cruiser
cruisers
cruising
cruises
crumb
crumbly
crumbs
crumble
crumbled
crumbling
crumbles
crumple
crumpled
crumpling
crumples
crunch
crunched
crunching
crunches
crunchy
crunchiest
crunchier
crusade
crusader
crusaders
crusading
crusades
crush
crushed
crusher
crushers
crushing
crushes
crushable
crushingly
crust
crust's
crusts
crustacean
crustacean's
crustaceans
crutch
crutch's
crutches
crux
crux's
cruxes
cry
cried
crier
criers
crying
cries
cryptanalysis
cryptographic
cryptography
cryptology
crystal
crystal's
crystals
crystalline
crystallize
crystallized
crystallizing
crystallizes
cub
cub's
cubs
cube
cubed
cubes
cubic
cuckoo
cuckoo's
cuckoos
cucumber
cucumber's
cucumbers
cuddle
cuddled
cudgel
cudgel's
cudgels
cue
cued
cues
cuff
cuff's
cuffs
cull
culled
culler
culling
culls
culminate
culminated
culminating
culmination
culminates
culprit
culprit's
culprits
cult
cult's
cults
cultivate
cultivated
cultivating
cultivation
cultivations
cultivates
cultivator
cultivator's
cultivators
cultural
culturally
culture
cultured
culturing
cultures
cumbersome
cumulative
cumulatively
cunning
cunningly
cup
cup's
cups
cupboard
cupboard's
cupboards
cupful
cupped
cupping
cur
curly
curs
curable
curably
curb
curbing
curbs
cure
cured
curing
cures
curfew
curfew's
curfews
curiosity
curiosity's
curiosities
curious
curiousest
curiouser
curiously
curl
curled
curler
curlers
curling
curls
currant
currant's
currants
currency
currency's
currencies
current
currentness
currently
currents
curricular
curriculum
curriculum's
curriculums
curry
curried
currying
curries
curse
cursed
cursing
cursive
curses
cursor
cursor's
cursors
cursorily
cursory
curt
curtness
curtly
curtail
curtailed
curtails
curtain
curtained
curtains
curtate
curtsy
curtsy's
curtsies
curvature
curve
curved
curving
curves
cushion
cushioned
cushioning
cushions
cusp
cusp's
cusps
custard
custodian
custodian's
custodians
custody
custom
customer
customers
customs
customarily
customary
customizable
customization
customization's
customizations
customize
customized
customizer
customizers
customizing
customizes
cut
cut's
cuts
cute
cutest
cutoff
cutter
cutter's
cutters
cutting
cuttingly
cuttings
cybernetic
cycle
cycled
cycling
cycles
cyclic
cyclically
cycloid
cycloid's
cycloids
cycloidal
cyclone
cyclone's
cyclones
cylinder
cylinder's
cylinders
cymbal
cymbal's
cymbals
cynical
cynically
cypress
cyst
cysts
cytology
czar
dabble
dabbled
dabbler
dabbling
dabbles
dad
dad's
dads
daddy
daemon
daemon's
daemons
daffodil
daffodil's
daffodils
dagger
daily
dailies
daintily
dainty
daintiness
dairy
daisy
daisy's
daisies
dale
dale's
dales
dam
dam's
dams
damage
damaged
damager
damagers
damaging
damages
damask
dame
damn
damned
damning
damns
damnation
damp
dampness
damper
damping
dampen
dampens
damsel
damsel's
damsels
dance
danced
dancer
dancers
dancing
dances
dandelion
dandelion's
dandelions
dandy
danger
danger's
dangers
dangerous
dangerously
dangle
dangled
dangling
dangles
dare
dared
darer
darers
daring
dares
daresay
daringly
dark
darkness
darkest
darker
darken
darkly
darling
darling's
darlings
darn
darned
darner
darning
darns
dart
darted
darter
darting
darts
dash
dashed
dasher
dashers
dashing
dashes
dashing
dashingly
data
database
database's
databases
date
dated
dater
dating
dative
dates
datum
daughter
daughterly
daughters
daunt
daunted
dauntless
dawn
dawned
dawning
dawns
day
day's
days
daybreak
daydream
daydreaming
daydreams
daylight
daylight's
daylights
daytime
daze
dazed
dazzle
dazzled
dazzler
dazzling
dazzles
dazzlingly
deacon
deacon's
deacons
dead
deadness
deaden
deadly
deadline
deadline's
deadlines
deadlock
deadlocked
deadlocking
deadlocks
deaf
deafness
deafest
deafer
deafen
deal
dealer
dealers
dealing
dealings
deals
deallocated
deallocation
dealt
dean
dean's
deans
dear
dearness
dearest
dearer
dearth
dearly
dearths
death
deathly
deathrate
deathrate's
deathrates
deaths
debatable
debate
debated
debater
debaters
debating
debates
debilitate
debilitated
debilitating
debilitates
debris
debt
debt's
debts
debtor
debug
debugs
debugged
debugger
debugger's
debuggers
debugging
decade
decade's
decades
decadence
decadent
decadently
decay
decayed
decaying
decays
decease
deceased
deceasing
deceases
deceit
deceitful
deceitfulness
deceitfully
deceive
deceived
deceiver
deceivers
deceiving
deceives
decelerate
decelerated
decelerating
deceleration
decelerates
december
decency
decency's
decencies
decent
decently
decentralization
decentralized
deception
deception's
deceptions
deceptive
deceptively
decidability
decidable
decide
decided
deciding
decides
decidedly
decimal
decimals
decimate
decimated
decimating
decimation
decimates
decipher
deciphered
decipherer
deciphering
deciphers
decision
decision's
decisions
decisive
decisiveness
decisively
deck
decked
decking
deckings
decks
declaration
declaration's
declarations
declarative
declaratively
declaratives
declare
declared
declarer
declarers
declaring
declares
declination
declination's
declinations
decline
declined
decliner
decliners
declining
declines
decode
decoded
decoder
decoders
decoding
decodings
decodes
decomposability
decomposable
decompose
decomposed
decomposing
decomposes
decomposition
decomposition's
decompositions
decompression
decorate
decorated
decorating
decoration
decorations
decorative
decorates
decorum
decouple
decoupled
decoupling
decouples
decoy
decoy's
decoys
decrease
decreased
decreasing
decreases
decreasingly
decree
decreed
decrees
decreeing
decrement
decremented
decrementing
decrements
dedicate
dedicated
dedicating
dedication
dedicates
deduce
deduced
deducer
deducing
deduces
deducible
deduct
deducted
deducting
deductive
deduction
deduction's
deductions
deed
deeded
deeding
deeds
deem
deemed
deeming
deems
deemphasize
deemphasized
deemphasizing
deemphasizes
deep
deepest
deeper
deepen
deeply
deeps
deepen
deepened
deepening
deepens
deer
default
defaulted
defaulter
defaulting
defaults
defeat
defeated
defeating
defeats
defect
defected
defecting
defective
defects
defection
defection's
defections
defend
defended
defender
defenders
defending
defends
defendant
defendant's
defendants
defenestrate
defenestrated
defenestrating
defenestration
defenestrates
defense
defensive
defenses
defenseless
defer
defers
deference
deferment
deferment's
deferments
deferrable
deferred
deferrer
deferrer's
deferrers
deferring
defiance
defiant
defiantly
deficiency
deficiencies
deficient
deficit
deficit's
deficits
defile
defiling
definable
define
defined
definer
defining
defines
definite
definiteness
definition
definitions
definitely
definition
definition's
definitions
definitional
definitive
deformation
deformation's
deformations
deformed
deformity
deformity's
deformities
deftly
defy
defied
defying
defies
degenerate
degenerated
degenerating
degeneration
degenerative
degenerates
degradable
degradation
degradation's
degradations
degrade
degraded
degrading
degrades
degree
degree's
degrees
deign
deigned
deigning
deigns
deity
deity's
deities
dejected
dejectedly
Delaware
delay
delayed
delaying
delays
delegate
delegated
delegating
delegation
delegations
delegates
delete
deleted
deleter
deleting
deletion
deletions
deletes
deliberate
deliberateness
deliberated
deliberating
deliberation
deliberations
deliberately
deliberates
deliberative
deliberator
deliberator's
deliberators
delicacy
delicacy's
delicacies
delicate
delicately
delicious
deliciously
delight
delighted
delighting
delights
delightedly
delightful
delightfully
delimit
delimited
delimiter
delimiters
delimiting
delimits
delineate
delineated
delineating
delineation
delineates
delirious
deliriously
deliver
delivered
deliverer
deliverers
delivering
delivers
deliverable
deliverables
deliverance
delivery
delivery's
deliveries
dell
dell's
dells
delta
delta's
deltas
delude
deluded
deluding
deludes
deluge
deluged
deluges
delusion
delusion's
delusions
delve
delving
delves
demand
demanded
demander
demanding
demands
demandingly
demeanor
demise
democracy
democracy's
democracies
democrat
democrat's
democrats
democratic
democratically
demographic
demolish
demolished
demolishes
demolition
demon
demon's
demons
demonstrable
demonstrate
demonstrated
demonstrating
demonstration
demonstrations
demonstrative
demonstrates
demonstratively
demonstrator
demonstrator's
demonstrators
demoralize
demoralized
demoralizing
demoralizes
demur
den
den's
dens
deniable
denial
denial's
denials
denigrate
denigrated
denigrating
denigrates
Denmark
denomination
denomination's
denominations
denominator
denominator's
denominators
denotable
denotation
denotation's
denotations
denotational
denotationally
denote
denoted
denoting
denotes
denounce
denounced
denouncing
denounces
dense
denseness
densest
denser
densely
density
density's
densities
dent
dented
denting
dents
dental
dentally
dentist
dentist's
dentists
deny
denied
denier
denying
denies
depart
departed
departing
departs
department
department's
departments
departmental
departure
departure's
departures
depend
depended
depending
depends
dependability
dependable
dependably
dependence
dependency
dependencies
dependent
dependently
dependents
depict
depicted
depicting
depicts
deplete
depleted
depleting
depletion
depletions
depletes
deplorable
deplore
deplored
deplores
deploy
deployed
deploying
deploys
deployment
deployment's
deployments
deportation
deportment
depose
deposed
deposes
deposit
deposited
depositing
deposits
deposition
deposition's
depositions
depositor
depositor's
depositors
depot
depot's
depots
deprave
depraved
depreciate
depreciation
depreciates
depress
depressed
depressing
depresses
depression
depression's
depressions
deprivation
deprivation's
deprivations
deprive
deprived
depriving
deprives
depth
depths
deputy
deputy's
deputies
dequeue
dequeued
dequeuing
dequeues
derail
derailed
derailing
derails
derby
deride
derision
derivable
derivation
derivation's
derivations
derivative
derivative's
derivatives
derive
derived
deriving
derives
descend
descended
descender
descenders
descending
descends
descendant
descendant's
descendants
descent
descent's
descents
describable
describe
described
describer
describing
describes
description
description's
descriptions
descriptive
descriptively
descriptives
descriptor
descriptor's
descriptors
descry
desert
deserted
deserter
deserters
deserting
deserts
desertion
desertions
deserve
deserved
deserving
deservings
deserves
deservingly
desiderata
desideratum
design
designed
designer
designers
designing
designs
designate
designated
designating
designation
designations
designates
designator
designator's
designators
designer's
desirability
desirable
desirably
desire
desired
desiring
desires
desirous
desk
desk's
desks
desolate
desolation
desolations
desolately
despair
despaired
despairing
despairs
despairingly
despatch
despatched
desperate
desperation
desperately
despise
despised
despising
despises
despite
despot
despot's
despots
despotic
dessert
dessert's
desserts
destination
destination's
destinations
destine
destined
destiny
destiny's
destinies
destitute
destitution
destroy
destroyed
destroying
destroys
destroyer
destroyer's
destroyers
destruction
destruction's
destructions
destructive
destructiveness
destructively
detach
detached
detacher
detaching
detaches
detachment
detachment's
detachments
detail
detailed
detailing
details
detain
detained
detaining
detains
detect
detected
detecting
detective
detects
detectable
detectably
detection
detection's
detections
detectives
detector
detector's
detectors
detention
deteriorate
deteriorated
deteriorating
deterioration
deteriorates
determinable
determinacy
determinant
determinant's
determinants
determinate
determination
determinations
determinative
determinately
determine
determined
determiner
determiners
determining
determines
determinism
deterministic
deterministically
detest
detested
detestable
detract
detracts
detractor
detractor's
detractors
detriment
devastate
devastated
devastating
devastation
devastates
develop
developed
developer
developers
developing
develops
development
development's
developments
developmental
deviant
deviant's
deviants
deviate
deviated
deviating
deviation
deviations
deviates
device
device's
devices
devil
devil's
devils
devilish
devilishly
devise
devised
devising
devisings
devises
devoid
devote
devoted
devoting
devotion
devotions
devotes
devotedly
devotee
devotee's
devotees
devour
devoured
devourer
devours
devout
devoutness
devoutly
dew
dewdrop
dewdrop's
dewdrops
dewy
dexterity
diadem
diagnosable
diagnose
diagnosed
diagnosing
diagnoses
diagnosis
diagnostic
diagnostic's
diagnostics
diagonal
diagonally
diagonals
diagram
diagram's
diagrams
diagrammable
diagrammatic
diagrammatically
diagrammed
diagrammer
diagrammer's
diagrammers
diagramming
dial
dialed
dialing
dials
dialect
dialect's
dialects
dialog
dialog's
dialogs
dialogue
dialogue's
dialogues
diameter
diameter's
diameters
diametrically
diamond
diamond's
diamonds
diaper
diaper's
diapers
diaphragm
diaphragm's
diaphragms
diary
diary's
diaries
diatribe
diatribe's
diatribes
dice
dichotomize
dichotomy
dickens
dicky
dictate
dictated
dictating
dictation
dictations
dictates
dictator
dictator's
dictators
dictatorship
diction
dictionary
dictionary's
dictionaries
dictum
dictum's
dictums
did
didn't
die
died
dies
dielectric
dielectric's
dielectrics
diet
dieter
dieters
diets
dietitian
dietitian's
dietitians
differ
differed
differer
differers
differing
differen
differs
difference
difference's
differences
different
differently
differential
differential's
differentials
differentiate
differentiated
differentiating
differentiation
differentiations
differentiates
differentiators
difficult
difficultly
difficulty
difficulty's
difficulties
diffuse
diffused
diffuser
diffusers
diffusing
diffusion
diffusions
diffusely
diffuses
dig
digs
digest
digested
digesting
digestive
digests
digestible
digestion
digger
digger's
diggers
digging
diggings
digit
digit's
digits
digital
digitally
dignify
dignified
dignity
dignities
digress
digressed
digressing
digressive
digresses
digression
digression's
digressions
dike
dike's
dikes
dilate
dilated
dilating
dilation
dilates
dilemma
dilemma's
dilemmas
diligence
diligent
diligently
dilute
diluted
diluting
dilution
dilutes
dim
dimness
dimly
dims
dime
dime's
dimes
dimension
dimensioned
dimensioning
dimensions
dimensional
dimensionally
dimensionality
diminish
diminished
diminishing
diminishes
diminution
diminutive
dimmed
dimmer
dimmer's
dimmers
dimmest
dimming
dimple
din
dine
dined
diner
diners
dining
dines
dingy
dinginess
dinner
dinner's
dinners
dint
diode
diode's
diodes
Diophantine
dioxide
dip
dips
diphtheria
diploma
diploma's
diplomas
diplomacy
diplomat
diplomat's
diplomats
diplomatic
dipped
dipper
dipper's
dippers
dipping
dippings
dire
direct
directness
directed
directing
directly
directs
direction
direction's
directions
directional
directionally
directionality
directive
directive's
directives
director
director's
directors
directory
directory's
directories
dirge
dirge's
dirges
dirt
dirts
dirtily
dirty
dirtiness
dirtiest
dirtier
disability
disability's
disabilities
disable
disabled
disabler
disablers
disabling
disables
disadvantage
disadvantage's
disadvantages
disagree
disagreed
disagreing
disagrees
disagreeable
disagreeing
disagreement
disagreement's
disagreements
disallow
disallowed
disallowing
disallows
disambiguate
disambiguated
disambiguating
disambiguation
disambiguations
disambiguates
disappear
disappeared
disappearing
disappears
disappearance
disappearance's
disappearances
disappoint
disappointed
disappointing
disappointment
disappointment's
disappointments
disapproval
disapprove
disapproved
disapproves
disarm
disarmed
disarming
disarms
disarmament
disassemble
disassembled
disassembling
disassembles
disaster
disaster's
disasters
disastrous
disastrously
disband
disbanded
disbanding
disbands
disburse
disbursed
disbursing
disburses
disbursement
disbursement's
disbursements
disc
disc's
discs
discard
discarded
discarding
discards
discern
discerned
discerning
discerns
discernibility
discernible
discernibly
discerningly
discernment
discharge
discharged
discharging
discharges
disciple
disciple's
disciples
disciplinary
discipline
disciplined
disciplining
disciplines
disclaim
disclaimed
disclaimer
disclaims
disclose
disclosed
disclosing
discloses
disclosure
disclosure's
disclosures
discomfort
disconcert
disconcerting
disconcertingly
disconnect
disconnected
disconnecting
disconnects
disconnection
discontent
discontented
discontinuance
discontinue
discontinued
discontinues
discontinuity
discontinuity's
discontinuities
discontinuous
discord
discount
discounted
discounting
discounts
discourage
discouraged
discouraging
discourages
discouragement
discourse
discourse's
discourses
discover
discovered
discoverer
discoverers
discovering
discovers
discovery
discovery's
discoveries
discredit
discredited
discreet
discreetly
discrepancy
discrepancy's
discrepancies
discrete
discreteness
discretion
discretely
discriminate
discriminated
discriminating
discrimination
discriminates
discriminatory
discuss
discussed
discussing
discusses
discussion
discussion's
discussions
disdain
disdaining
disdains
disease
diseased
diseases
disengage
disengaged
disengaging
disengages
disfigure
disfigured
disfiguring
disfigures
disgorge
disgrace
disgraced
disgraces
disgraceful
disgracefully
disgruntled
disguise
disguised
disguises
disgust
disgusted
disgusting
disgusts
disgustedly
disgustingly
dish
dished
dishing
dishes
dishearten
disheartening
dishonest
dishonestly
dishonor
dishonored
dishonoring
dishonors
dishwashers
dishwashing
disillusion
disillusioned
disillusioning
disillusionment
disillusionment's
disillusionments
disinterested
disinterestedness
disjoint
disjointness
disjointed
disjunct
disjunctive
disjuncts
disjunction
disjunctions
disjunctively
disk
disk's
disks
dislike
disliked
disliking
dislikes
dislocate
dislocated
dislocating
dislocation
dislocations
dislocates
dislodge
dislodged
dismal
dismally
dismay
dismayed
dismaying
dismiss
dismissed
dismisser
dismissers
dismissing
dismisses
dismissal
dismissal's
dismissals
dismount
dismounted
dismounting
dismounts
disobedience
disobey
disobeyed
disobeying
disobeys
disorder
disordered
disorderly
disorders
disorganized
disown
disowned
disowning
disowns
disparate
disparity
disparity's
disparities
dispatch
dispatched
dispatcher
dispatchers
dispatching
dispatches
dispel
dispels
dispell
dispelled
dispelling
dispells
dispensation
dispense
dispensed
dispenser
dispensers
dispensing
dispenses
disperse
dispersed
dispersing
dispersion
dispersions
disperses
displace
displaced
displacing
displaces
displacement
displacement's
displacements
display
displayed
displaying
displays
displease
displeased
displeasing
displeases
displeasure
disposable
disposal
disposal's
disposals
dispose
disposed
disposer
disposing
disposes
disposition
disposition's
dispositions
disprove
disproved
disproving
disproves
dispute
disputed
disputer
disputers
disputing
disputes
disqualify
disqualified
disqualifying
disqualification
disqualifies
disquiet
disquieting
disregard
disregarded
disregarding
disregards
disrupt
disrupted
disrupting
disruptive
disrupts
disruption
disruption's
disruptions
dissatisfaction
dissatisfaction's
dissatisfactions
dissatisfied
disseminate
disseminated
disseminating
dissemination
disseminates
dissension
dissension's
dissensions
dissent
dissented
dissenter
dissenters
dissenting
dissents
dissertation
dissertation's
dissertations
disservice
dissident
dissident's
dissidents
dissimilar
dissimilarity
dissimilarity's
dissimilarities
dissipate
dissipated
dissipating
dissipation
dissipates
dissociate
dissociated
dissociating
dissociation
dissociates
dissolution
dissolution's
dissolutions
dissolve
dissolved
dissolving
dissolves
distal
distally
distance
distances
distant
distantly
distaste
distastes
distasteful
distastefully
distemper
distill
distilled
distiller
distillers
distilling
distills
distillation
distinct
distinctness
distinctly
distinction
distinction's
distinctions
distinctive
distinctiveness
distinctively
distinguish
distinguished
distinguishing
distinguishes
distinguishable
distort
distorted
distorting
distorts
distortion
distortion's
distortions
distract
distracted
distracting
distracts
distraction
distraction's
distractions
distraught
distress
distressed
distressing
distresses
distribute
distributed
distributing
distribution
distributive
distributes
distribution
distribution's
distributions
distributional
distributivity
distributor
distributor's
distributors
district
district's
districts
distritbute
distritbuted
distritbuting
distritbutes
distrust
distrusted
disturb
disturbed
disturber
disturbing
disturbs
disturbance
disturbance's
disturbances
disturbingly
ditch
ditch's
ditches
divan
divan's
divans
dive
dived
diver
divers
diving
dives
diverge
diverged
diverging
diverges
divergence
divergence's
divergences
divergent
diverse
diversion
diversions
diversely
diversify
diversified
diversifying
diversification
diversifies
diversity
diversities
divert
diverted
diverting
diverts
divest
divested
divesting
divests
divide
divided
divider
dividers
dividing
divides
dividend
dividend's
dividends
divine
diviner
divining
divinely
divinity
divinity's
divinities
division
division's
divisions
divisor
divisor's
divisors
divorce
divorced
divulge
divulged
divulging
divulges
dizzy
dizziness
do
doer
doers
doing
doings
dock
docked
docks
doctor
doctored
doctors
doctoral
doctorate
doctorate's
doctorates
doctrine
doctrine's
doctrines
document
documented
documenter
documenters
documenting
documents
documentary
documentary's
documentaries
documentation
documentation's
documentations
dodge
dodged
dodger
dodgers
dodging
does
doesn't
dog
dog's
dogs
dogged
doggedness
doggedly
dogging
dogma
dogma's
dogmas
dogmatism
dole
doled
doles
doleful
dolefully
doll
doll's
dolls
dollar
dollars
dolly
dolly's
dollies
dolphin
dolphin's
dolphins
domain
domain's
domains
dome
domed
domes
domestic
domestically
domesticate
domesticated
domesticating
domestication
domesticates
dominance
dominant
dominantly
dominate
dominated
dominating
domination
dominates
dominion
don
dons
don't
donate
donated
donating
donates
done
donkey
donkey's
donkeys
doom
doomed
dooming
dooms
door
door's
doors
doorstep
doorstep's
doorsteps
doorway
doorway's
doorways
dope
doped
doper
dopers
doping
dopes
dormant
dormitory
dormitory's
dormitories
dose
dosed
doses
dot
dot's
dots
dote
doted
doting
dotes
dotingly
dotted
dotting
double
doubled
doubler
doublers
doubling
doubles
doublet
doublet's
doublets
doubly
doubt
doubted
doubter
doubters
doubting
doubts
doubtable
doubtful
doubtfully
doubtless
doubtlessly
dough
doughnut
doughnut's
doughnuts
dove
dover
doves
down
downed
downers
downing
downs
downcast
downfall
downfallen
downplay
downplayed
downplaying
downplays
downright
downstairs
downstream
downtown
downtowns
downward
downwards
downy
doze
dozed
dozing
dozes
dozen
dozenth
dozens
drab
draft
drafted
drafter
drafters
drafting
drafts
draftsman
draftsmen
drag
drags
dragged
dragging
dragon
dragon's
dragons
dragoon
dragooned
dragoons
drain
drained
drainer
draining
drains
drainage
drake
drama
drama's
dramas
dramatic
dramatics
dramatically
dramatist
dramatist's
dramatists
drank
drape
draped
draper
drapers
drapes
drapery
drapery's
draperies
drastic
drastically
draught
draught's
draughts
draw
drawer
drawers
drawing
drawings
draws
drawback
drawback's
drawbacks
drawbridge
drawbridge's
drawbridges
drawl
drawled
drawling
drawls
drawn
drawnness
drawnly
dread
dreaded
dreading
dreads
dreadful
dreadfully
dream
dreamed
dreamer
dreamers
dreaming
dreams
dreamily
dreamy
dreary
dreariness
dregs
drench
drenched
drenching
drenches
dress
dressed
dresser
dressers
dressing
dressings
dresses
dressmaker
dressmaker's
dressmakers
drew
drier
drier's
driers
drift
drifted
drifter
drifters
drifting
drifts
drill
drilled
driller
drilling
drills
drily
drink
drinker
drinkers
drinking
drinks
drinkable
drip
drip's
drips
drive
driver
drivers
driving
drives
driven
driveway
driveway's
driveways
drone
drone's
drones
droop
drooped
drooping
droops
drop
drop's
drops
dropped
dropper
dropper's
droppers
dropping
dropping's
droppings
drought
drought's
droughts
drove
drover
drovers
droves
drown
drowned
drowning
drownings
drowns
drowsy
drowsiness
drudgery
drug
drug's
drugs
druggist
druggist's
druggists
drum
drum's
drums
drummed
drummer
drummer's
drummers
drumming
drunk
drunker
drunken
drunkly
drunks
drunkard
drunkard's
drunkards
drunkenness
dry
dried
driest
drying
dryly
dries
dual
duality
duality's
dualities
dub
dubs
dubious
dubiousness
dubiously
duchess
duchess's
duchesses
duchy
duck
ducked
ducking
ducks
due
dues
duel
dueling
duels
dug
duke
duke's
dukes
dull
dullness
dulled
dullest
duller
dulling
dulls
dully
duly
dumb
dumbness
dumbest
dumber
dumbly
dumbbell
dumbbell's
dumbbells
dummy
dummy's
dummies
dump
dumped
dumper
dumping
dumps
dunce
dunce's
dunces
dune
dune's
dunes
dungeon
dungeon's
dungeons
duplicate
duplicated
duplicating
duplication
duplications
duplicates
duplicator
duplicator's
duplicators
durability
durabilities
durable
durably
duration
duration's
durations
during
dusk
dusky
duskiness
dust
dusted
duster
dusters
dusting
dusts
dusty
dustiest
dustier
dutiful
dutifulness
dutifully
duty
duty's
duties
dwarf
dwarfed
dwarfs
dwell
dwelled
dweller
dwellers
dwelling
dwellings
dwells
dwindle
dwindled
dwindling
dye
dyed
dyer
dyers
dying
dyes
dyeing
dynamic
dynamics
dynamically
dynamite
dynamited
dynamiting
dynamites
dynasty
dynasty's
dynasties
each
eager
eagerness
eagerly
eagle
eagle's
eagles
ear
eared
earth
ears
earl
earl's
earls
early
earliness
earliest
earlier
earmark
earmarked
earmarking
earmarkings
earmarks
earn
earned
earnest
earning
earnings
earns
earner
earner's
earners
earnestly
earnestness
earring
earring's
earrings
earthen
earthenware
earthly
earthliness
earthquake
earthquake's
earthquakes
earths
earthworm
earthworm's
earthworms
ease
eased
easing
eases
easement
easement's
easements
easily
east
easter
eastern
Easterner
Easterners
eastward
eastwards
easy
easiness
easiest
easier
eat
eater
eaters
eating
eaten
eatings
eats
eaves
eavesdrop
eavesdrops
eavesdropped
eavesdropper
eavesdropper's
eavesdroppers
eavesdropping
ebb
ebbing
ebbs
ebony
eccentric
eccentric's
eccentrics
eccentricity
eccentricities
ecclesiastical
echo
echoed
echoing
echoes
eclipse
eclipsed
eclipsing
eclipses
ecology
economic
economics
economical
economically
economist
economist's
economists
economize
economized
economizer
economizers
economizing
economizes
economy
economy's
economies
ecstasy
eddy
eddy's
eddies
edge
edged
edging
edges
edible
edict
edict's
edicts
edifice
edifice's
edifices
edit
edited
editing
edits
edition
edition's
editions
editor
editor's
editors
editorial
editorially
editorials
educate
educated
educating
education
educations
educates
educational
educationally
educator
educator's
educators
eel
eel's
eels
eerie
effect
effected
effecting
effective
effects
effectively
effectiveness
effector
effector's
effectors
effectually
effeminate
efficacy
efficiency
efficiencies
efficient
efficiently
effigy
effort
effort's
efforts
effortless
effortlessness
effortlessly
egg
egged
egging
eggs
ego
egos
eigenvalue
eigenvalue's
eigenvalues
eight
eights
eighteen
eighteenth
eighteens
eighth
eighth's
eighthes
eighty
eightieth
eighties
either
ejaculate
ejaculated
ejaculating
ejaculation
ejaculations
ejaculates
eject
ejected
ejecting
ejects
eke
eked
ekes
el
elaborate
elaborateness
elaborated
elaborating
elaboration
elaborations
elaborately
elaborates
elaborators
elapse
elapsed
elapsing
elapses
elastic
elastically
elasticity
elbow
elbowing
elbows
elder
elderly
elders
eldest
elect
elected
electing
elective
elects
election
election's
elections
electives
elector
elector's
electors
electoral
electric
electrical
electricalness
electrically
electricity
electrify
electrifying
electrification
electrocute
electrocuted
electrocuting
electrocution
electrocutions
electrocutes
electrode
electrode's
electrodes
electrolyte
electrolyte's
electrolytes
electrolytic
electron
electron's
electrons
electronic
electronics
electronically
elegance
elegant
elegantly
element
element's
elements
elemental
elementals
elementary
elephant
elephant's
elephants
elevate
elevated
elevation
elevates
elevator
elevator's
elevators
eleven
eleventh
elevens
elf
elicit
elicited
eliciting
elicits
eligibility
eligible
eliminate
eliminated
eliminating
elimination
eliminations
eliminates
eliminator
eliminators
elk
elk's
elks
ellipse
ellipse's
ellipses
ellipsis
ellipsoid
ellipsoid's
ellipsoids
ellipsoidal
elliptic
elliptical
elliptically
elm
elmer
elms
eloquence
eloquent
eloquently
else
elsewhere
elucidate
elucidated
elucidating
elucidation
elucidates
elude
eluded
eluding
eludes
elusive
elusiveness
elusively
elves
emaciated
emanating
emancipation
embark
embarked
embarks
embarrass
embarrassed
embarrassing
embarrasses
embarrassment
embassy
embassy's
embassies
embed
embeds
embedded
embedding
embellish
embellished
embellishing
embellishes
embellishment
embellishment's
embellishments
ember
emblem
embodiment
embodiment's
embodiments
embody
embodied
embodying
embodies
embrace
embraced
embracing
embraces
embroider
embroidered
embroiders
embroidery
embroideries
embryo
embryo's
embryos
embryology
emerald
emerald's
emeralds
emerge
emerged
emerging
emerges
emergence
emergency
emergency's
emergencies
emergent
emery
emigrant
emigrant's
emigrants
emigrate
emigrated
emigrating
emigration
emigrates
eminence
eminent
eminently
emit
emits
emitted
emotion
emotion's
emotions
emotional
emotionally
empathy
emperor
emperor's
emperors
emphases
emphasis
emphasize
emphasized
emphasizing
emphasizes
emphatic
emphatically
empire
empire's
empires
empirical
empirically
empiricist
empiricist's
empiricists
employ
employed
employing
employs
employable
employee
employee's
employees
employer
employer's
employers
employment
employment's
employments
empower
empowered
empowering
empowers
empress
emptily
empty
emptiness
emptied
emptiest
emptier
emptying
empties
emulate
emulated
emulation
emulations
emulates
emulator
emulator's
emulators
enable
enabled
enabler
enablers
enabling
enables
enact
enacted
enacting
enacts
enactment
enamel
enameled
enameling
enamels
encamp
encamped
encamping
encamps
encapsulate
encapsulated
encapsulating
encapsulation
encapsulates
enchant
enchanted
enchanter
enchanting
enchants
enchantment
encipher
enciphered
enciphering
enciphers
encircle
encircled
encircles
enclose
enclosed
enclosing
encloses
enclosure
enclosure's
enclosures
encode
encoded
encoder
encoding
encodings
encodes
encompass
encompassed
encompassing
encompasses
encounter
encountered
encountering
encounters
encourage
encouraged
encouraging
encourages
encouragement
encouragements
encouragingly
encrypt
encrypted
encrypting
encrypts
encryption
encumber
encumbered
encumbering
encumbers
encyclopedia
encyclopedia's
encyclopedias
encyclopedic
end
ended
ender
enders
ending
endings
ends
endanger
endangered
endangering
endangers
endear
endeared
endearing
endears
endeavor
endeavored
endeavoring
endeavors
endless
endlessness
endlessly
endorse
endorsed
endorsing
endorses
endorsement
endow
endowed
endowing
endows
endowment
endowment's
endowments
endurable
endurably
endurance
endure
endured
enduring
endures
enduringly
enema
enema's
enemas
enemy
enemy's
enemies
energetic
energy
energies
enforce
enforced
enforcer
enforcers
enforcing
enforces
enforcement
engage
engaged
engaging
engages
engagement
engagement's
engagements
engagingly
engender
engendered
engendering
engenders
engine
engine's
engines
engineer
engineered
engineer's
engineering
engineers
England
Englander
Englanders
English
engrave
engraved
engraver
engraving
engravings
engraves
engross
engrossed
engrossing
enhance
enhanced
enhancing
enhances
enhancement
enhancement's
enhancements
enigmatic
enjoin
enjoined
enjoining
enjoins
enjoy
enjoyed
enjoying
enjoys
enjoyable
enjoyably
enjoyment
enlarge
enlarged
enlarger
enlargers
enlarging
enlarges
enlargement
enlargement's
enlargements
enlighten
enlightened
enlightening
enlightenment
enlist
enlisted
enlists
enlistment
enliven
enlivened
enlivening
enlivens
enmity
enmities
ennoble
ennobled
ennobling
ennobles
ennui
enormity
enormities
enormous
enormously
enough
enqueue
enqueued
enqueues
enquire
enquired
enquirer
enquires
enrage
enraged
enraging
enrages
enrich
enriched
enriching
enriches
enroll
enrolled
enrolling
enrolls
enrollment
enrollment's
enrollments
ensemble
ensemble's
ensembles
ensign
ensign's
ensigns
enslave
enslaved
enslaving
enslaves
ensnare
ensnared
ensnaring
ensnares
ensue
ensued
ensuing
ensues
ensure
ensured
ensurer
ensurers
ensuring
ensures
entail
entailed
entailing
entails
entangle
enter
entered
entering
enters
enterprise
enterprising
enterprises
entertain
entertained
entertainer
entertainers
entertaining
entertains
entertainingly
entertainment
entertainment's
entertainments
enthusiasm
enthusiasms
enthusiast
enthusiast's
enthusiasts
enthusiastic
enthusiastically
entice
enticed
enticer
enticers
enticing
entices
entire
entirely
entirety
entireties
entitle
entitled
entitling
entitles
entity
entity's
entities
entrance
entranced
entrances
entreat
entreated
entreaty
entrench
entrenched
entrenching
entrenches
entrepreneur
entrepreneur's
entrepreneurs
entropy
entrust
entrusted
entrusting
entrusts
entry
entry's
entries
enumerable
enumerate
enumerated
enumerating
enumeration
enumerative
enumerates
enumerator
enumerators
enunciation
envelop
envelops
envelope
enveloped
enveloper
enveloping
envelopes
envious
enviousness
enviously
environ
environing
environs
environment
environment's
environments
environmental
envisage
envisaged
envisages
envision
envisioned
envisioning
envisions
envoy
envoy's
envoys
envy
envied
envies
epaulet
epaulet's
epaulets
ephemeral
epic
epic's
epics
epidemic
epidemic's
epidemics
Episcopal
episode
episode's
episodes
epistemological
epistemology
epistle
epistle's
epistles
epitaph
epitaphs
epitaxial
epitaxially
epithet
epithet's
epithets
epitomize
epitomized
epitomizing
epitomizes
epoch
epochs
epsilon
equal
equaled
equaling
equally
equals
equality
equality's
equalities
equalize
equalized
equalizer
equalizers
equalizing
equalizes
equate
equated
equating
equation
equations
equates
equator
equator's
equators
equatorial
equilibrium
equilibriums
equip
equips
equipment
equipped
equipping
equitable
equitably
equity
equivalence
equivalences
equivalent
equivalently
equivalents
era
era's
eras
eradicate
eradicated
eradicating
eradication
eradicates
erasable
erase
erased
eraser
erasers
erasing
erases
erasure
ere
erect
erected
erecting
erects
erection
erection's
erections
erector
erector's
erectors
ergo
ermine
ermine's
ermines
err
erred
erring
errs
errand
erratic
erringly
erroneous
erroneousness
erroneously
error
error's
errors
eruption
escalate
escalated
escalating
escalation
escalates
escapable
escapade
escapade's
escapades
escape
escaped
escaping
escapes
escapee
escapee's
escapees
eschew
eschewed
eschewing
eschews
escort
escorted
escorting
escorts
esoteric
especial
especially
espionage
espouse
espoused
espousing
espouses
esprit
espy
esquire
esquires
essay
essayed
essays
essence
essence's
essences
essential
essentially
essentials
establish
established
establishing
establishes
establishment
establishment's
establishments
estate
estate's
estates
esteem
esteemed
esteeming
esteems
estimate
estimated
estimating
estimation
estimations
estimates
etc
eternal
eternally
eternity
eternities
ether
ether's
ethers
ethereal
ethereally
ethical
ethically
ethics
ethnic
etiquette
eunuch
eunuchs
euphemism
euphemism's
euphemisms
euphoria
Europe
European
Europeans
evacuate
evacuated
evacuation
evade
evaded
evading
evades
evaluate
evaluated
evaluating
evaluation
evaluations
evaluative
evaluates
evaluator
evaluator's
evaluators
evaporate
evaporated
evaporating
evaporation
evaporative
eve
ever
even
evenness
evened
evenly
evens
evenhanded
evenhandedness
evenhandedly
evening
evening's
evenings
event
event's
events
eventful
eventfully
eventual
eventually
eventuality
eventualities
evergreen
everlasting
everlastingly
evermore
every
everybody
everyday
everyone
everyone's
everything
everywhere
evict
evicted
evicting
evicts
eviction
eviction's
evictions
evidence
evidenced
evidencing
evidences
evident
evidently
evil
evilly
evils
eviller
evince
evinced
evinces
evoke
evoked
evoking
evokes
evolute
evolute's
evolutes
evolution
evolution's
evolutions
evolutionary
evolve
evolved
evolving
evolves
ewe
ewe's
ewes
exacerbate
exacerbated
exacerbating
exacerbation
exacerbations
exacerbates
exact
exactness
exacted
exacting
exactly
exacts
exactingly
exaction
exaction's
exactions
exactitude
exaggerate
exaggerated
exaggerating
exaggeration
exaggerations
exaggerates
exalt
exalted
exalting
exalts
exam
exam's
exams
examination
examination's
examinations
examine
examined
examiner
examiners
examining
examines
example
example's
examples
exasperate
exasperated
exasperating
exasperation
exasperates
excavate
excavated
excavating
excavation
excavations
excavates
exceed
exceeded
exceeding
exceeds
exceedingly
excel
excels
excelled
excellence
excellences
excellency
excellent
excellently
excelling
except
excepted
excepting
excepts
exception
exception's
exceptions
exceptional
exceptionally
excerpt
excerpted
excerpts
excess
excessive
excesses
excessively
exchange
exchanged
exchanging
exchanges
exchangeable
exchequer
exchequer's
exchequers
excise
excised
excising
excision
excises
excitable
excitation
excitation's
excitations
excite
excited
exciting
excites
excitedly
excitement
excitingly
exclaim
exclaimed
exclaimer
exclaimers
exclaiming
exclaims
exclamation
exclamation's
exclamations
exclude
excluded
excluding
excludes
exclusion
exclusions
exclusive
exclusiveness
exclusively
exclusivity
excommunicate
excommunicated
excommunicating
excommunication
excommunicates
excrete
excreted
excreting
excretion
excretions
excretes
excursion
excursion's
excursions
excusable
excusably
excuse
excused
excusing
excuses
executable
execute
executed
executing
execution
executions
executive
executes
executional
executive
executive's
executives
executor
executor's
executors
exemplar
exemplary
exemplify
exemplified
exemplifier
exemplifiers
exemplifying
exemplification
exemplifies
exempt
exempted
exempting
exempts
exercise
exercised
exerciser
exercisers
exercising
exercises
exert
exerted
exerting
exerts
exertion
exertion's
exertions
exhale
exhaled
exhaling
exhales
exhaust
exhausted
exhausting
exhaustive
exhausts
exhaustable
exhaustedly
exhaustion
exhaustively
exhibit
exhibited
exhibiting
exhibits
exhibition
exhibition's
exhibitions
exhibitor
exhibitor's
exhibitors
exhortation
exhortation's
exhortations
exile
exiled
exiling
exiles
exist
existed
existing
exists
existence
existent
existential
existentially
existentialism
existentialist
existentialist's
existentialists
exit
exited
exiting
exits
exorbitant
exorbitantly
exotic
expand
expanded
expanding
expands
expandable
expander
expander's
expanders
expanse
expansion
expansions
expansive
expanses
expansionism
expect
expected
expecting
expects
expectancy
expectant
expectantly
expectation
expectation's
expectations
expectedly
expectingly
expedient
expediently
expedite
expedited
expediting
expedites
expedition
expedition's
expeditions
expeditious
expeditiously
expel
expels
expelled
expelling
expend
expended
expending
expends
expendable
expenditure
expenditure's
expenditures
expense
expensive
expenses
expensively
experience
experienced
experiencing
experiences
experiment
experimented
experimenter
experimenters
experimenting
experiments
experimental
experimentally
experimentation
experimentation's
experimentations
expert
expertness
expertly
experts
expertise
expiration
expiration's
expirations
expire
expired
expires
explain
explained
explainer
explainers
explaining
explains
explainable
explanation
explanation's
explanations
explanatory
explicit
explicitness
explicitly
explode
exploded
exploding
explodes
exploit
exploited
exploiter
exploiters
exploiting
exploits
exploitable
exploitation
exploitation's
exploitations
exploration
exploration's
explorations
exploratory
explore
explored
explorer
explorers
exploring
explores
explosion
explosion's
explosions
explosive
explosively
explosives
exponent
exponent's
exponents
exponential
exponentially
exponentials
exponentiate
exponentiated
exponentiating
exponentiates
exponentiation
exponentiation's
exponentiations
export
exported
exporter
exporters
exporting
exports
expose
exposed
exposer
exposers
exposing
exposes
exposition
exposition's
expositions
expository
exposure
exposure's
exposures
expound
expounded
expounder
expounding
expounds
express
expressed
expressing
expressive
expressly
expresses
expressibility
expressible
expressibly
expression
expression's
expressions
expressively
expressiveness
expulsion
expunge
expunged
expunging
expunges
exquisite
exquisiteness
exquisitely
extant
extend
extended
extending
extends
extendable
extensibility
extensible
extension
extension's
extensions
extensive
extensively
extent
extent's
extents
extenuate
extenuated
extenuating
extenuation
exterior
exterior's
exteriors
exterminate
exterminated
exterminating
extermination
exterminates
external
externally
extinct
extinction
extinguish
extinguished
extinguisher
extinguishing
extinguishes
extol
extra
extras
extract
extracted
extracting
extracts
extraction
extraction's
extractions
extractor
extractor's
extractors
extracurricular
extraneous
extraneousness
extraneously
extraordinarily
extraordinary
extraordinariness
extrapolate
extrapolated
extrapolating
extrapolation
extrapolations
extrapolates
extravagance
extravagant
extravagantly
extremal
extreme
extremely
extremes
extremist
extremist's
extremists
extremity
extremity's
extremities
extrinsic
exuberance
exult
exultation
eye
eyed
eyer
eyers
eying
eyes
eyebrow
eyebrow's
eyebrows
eyeglass
eyeglasses
eyeing
eyelid
eyelid's
eyelids
eyepiece
eyepiece's
eyepieces
eyesight
eyewitness
eyewitness's
eyewitnesses
fable
fabled
fables
fabric
fabric's
fabrics
fabricate
fabricated
fabricating
fabrication
fabricates
fabulous
fabulously
facade
facaded
facades
face
faced
facing
facings
faces
facet
faceted
facets
facial
facile
facilely
facilitate
facilitated
facilitating
facilitates
facility
facility's
facilities
facsimile
facsimile's
facsimiles
fact
fact's
facts
faction
faction's
factions
factor
factored
factoring
factors
factorial
factorization
factorization's
factorizations
factory
factory's
factories
factual
factually
faculty
faculty's
faculties
fade
faded
fader
faders
fading
fades
fag
fags
fail
failed
failing
failings
fails
failure
failure's
failures
fain
faint
faintness
fainted
faintest
fainter
fainting
faintly
faints
fair
fairness
fairest
fairer
fairing
fairly
fairs
fairy
fairy's
fairies
fairyland
faith
faithful
faithfulness
faithfully
faithless
faithlessness
faithlessly
faiths
fake
faked
faker
faking
fakes
falcon
falconer
falcons
fall
falling
fallen
falls
fallacious
fallacy
fallacy's
fallacies
fallibility
fallible
false
falseness
falsely
falsehood
falsehood's
falsehoods
falsify
falsified
falsifying
falsification
falsifies
falsity
falter
faltered
falters
fame
famed
fames
familiar
familiarness
familiarly
familiarity
familiarities
familiarization
familiarize
familiarized
familiarizing
familiarizes
family
family's
families
famine
famine's
famines
famish
famous
famously
fan
fan's
fans
fanatic
fanatic's
fanatics
fancier
fancier's
fanciers
fanciful
fancifully
fancily
fancy
fanciness
fancied
fanciest
fancying
fancies
fang
fang's
fangs
fanned
fanning
fantastic
fantasy
fantasy's
fantasies
far
faraway
farce
farce's
farces
fare
fared
faring
fares
farewell
farewells
farm
farmed
farmer
farmers
farming
farms
farmhouse
farmhouse's
farmhouses
farmyard
farmyard's
farmyards
farth
farthest
farther
farthing
fascinate
fascinated
fascinating
fascination
fascinates
fashion
fashioned
fashioning
fashions
fashionable
fashionably
fast
fastness
fasted
fastest
faster
fasting
fastens
fasts
fasten
fastened
fastener
fasteners
fastening
fastenings
fastens
fat
fatness
fats
fatal
fatally
fatals
fatality
fatality's
fatalities
fate
fated
fates
father
fathered
father's
fatherly
fathers
fatherland
fathom
fathomed
fathoming
fathoms
fatigue
fatigued
fatiguing
fatigues
fatten
fattened
fattener
fatteners
fattening
fattens
fatter
fattest
fault
faulted
faulting
faults
faultless
faultlessly
faulty
favor
favored
favorer
favoring
favors
favorable
favorably
favorite
favorites
fawn
fawned
fawning
fawns
fear
feared
fearing
fears
fearful
fearfully
fearless
fearlessness
fearlessly
feasibility
feasible
feast
feasted
feasting
feasts
feat
feat's
feats
feather
feathered
featherer
featherers
feathering
feathers
feature
featured
featuring
features
February
February's
Februaries
fed
federal
federally
federals
federation
fee
fees
feeble
feebleness
feeblest
feebler
feebly
feed
feeded
feeder
feeders
feeding
feedings
feeds
feedback
feel
feeler
feelers
feeling
feelings
feels
feelingly
feet
feign
feigned
feigning
felicity
felicities
fell
felled
felling
fellow
fellow's
fellows
fellowship
fellowship's
fellowships
felt
felts
female
female's
females
feminine
femininity
femur
femur's
femurs
fen
fens
fence
fenced
fencer
fencers
fencing
fences
ferment
fermented
fermenting
ferments
fermentation
fermentation's
fermentations
fern
fern's
ferns
ferocious
ferociousness
ferociously
ferocity
ferrite
ferry
ferried
ferries
fertile
fertilely
fertility
fertilization
fertilize
fertilized
fertilizer
fertilizers
fertilizing
fertilizes
fervent
fervently
fervor
fervor's
fervors
festival
festival's
festivals
festive
festively
festivity
festivities
fetch
fetched
fetching
fetches
fetchingly
fetter
fettered
fetters
feud
feud's
feuds
feudal
feudalism
fever
fevered
fevers
feverish
feverishly
few
fewness
fewest
fewer
fiber
fiber's
fibers
fibrosity
fibrosities
fibrous
fibrously
fickle
fickleness
fiction
fiction's
fictions
fictional
fictionally
fictitious
fictitiously
fiddle
fiddler
fiddling
fiddles
fidelity
field
fielded
fielder
fielders
fielding
fields
fiend
fierce
fierceness
fiercest
fiercer
fiercely
fiery
fife
fifo
fifteen
fifteenth
fifteens
fifth
fifty
fiftieth
fifties
fig
fig's
figs
fight
fighter
fighters
fighting
fights
figurative
figuratively
figure
figured
figuring
figurings
figures
filament
filament's
filaments
file
filed
filer
file's
filing
filings
files
filename
filename's
filenames
filial
fill
filled
filler
fillers
filling
fillings
fills
fillable
film
filmed
filming
films
filter
filtered
filter's
filtering
filters
filth
filthy
filthiness
filthiest
filthier
fin
fin's
fins
final
finally
finals
finality
finalization
finalize
finalized
finalizing
finalizes
finance
financed
financing
finances
financial
financially
financier
financier's
financiers
find
finder
finders
finding
findings
finds
fine
fineness
fined
finest
finer
fining
finely
fines
finger
fingered
fingering
fingerings
fingers
finish
finished
finisher
finishers
finishing
finishes
finite
finiteness
finitely
fir
fire
fired
firer
firers
firing
firings
fires
firearm
firearm's
firearms
firefly
firefly's
fireflies
firelight
fireman
fireplace
fireplace's
fireplaces
fireside
firewood
fireworks
firm
firmness
firmed
firmest
firmer
firming
firmly
firms
firmament
firmware
first
firstly
firsts
firsthand
fiscal
fiscally
fish
fished
fisher
fishers
fishing
fishes
fisherman
fishery
fissure
fissured
fist
fisted
fists
fit
fitness
fitly
fits
fitful
fitfully
fitted
fitter
fitter's
fitters
fitting
fittingly
fittings
five
fives
fix
fixed
fixer
fixers
fixing
fixings
fixes
fixate
fixated
fixating
fixation
fixations
fixates
fixedly
fixedness
fixture
fixture's
fixtures
flag
flag's
flags
flagged
flagging
flagrant
flagrantly
flake
flaked
flaking
flakes
flame
flamed
flamer
flamers
flaming
flames
flammable
flank
flanked
flanker
flanking
flanks
flannel
flannel's
flannels
flap
flap's
flaps
flare
flared
flaring
flares
flash
flashed
flasher
flashers
flashing
flashes
flashlight
flashlight's
flashlights
flask
flat
flatness
flatly
flats
flatten
flattened
flattening
flatter
flattered
flatterer
flattering
flattery
flattest
flaunt
flaunted
flaunting
flaunts
flavor
flavored
flavoring
flavorings
flavors
flaw
flawed
flaws
flawless
flawlessly
flax
flaxen
flea
flea's
fleas
fled
fledged
fledgling
fledgling's
fledglings
flee
flees
fleece
fleece's
fleeces
fleecy
fleeing
fleet
fleetness
fleetest
fleeting
fleetly
fleets
flesh
fleshed
fleshing
fleshly
fleshes
fleshy
flew
flexibility
flexibilities
flexible
flexibly
flick
flicked
flicker
flicking
flicks
flickering
flight
flight's
flights
flinch
flinched
flinching
flinches
fling
fling's
flings
flint
flip
flips
flirt
flirted
flirting
flirts
flit
float
floated
floater
floating
floats
flock
flocked
flocking
flocks
flood
flooded
flooding
floods
floor
floored
flooring
floorings
floors
flop
flop's
flops
floppily
floppy
flora
Florida
florin
floss
flossed
flossing
flosses
flounder
floundered
floundering
flounders
flour
floured
flourish
flourished
flourishing
flourishes
flow
flowed
flowers
flowing
flows
flowchart
flowcharting
flowcharts
flower
flowered
flowering
flowers
flowery
floweriness
flown
fluctuate
fluctuating
fluctuation
fluctuations
fluctuates
fluent
fluently
fluffy
fluffiest
fluffier
fluid
fluidly
fluids
fluidity
flung
flurry
flurried
flush
flushed
flushing
flushes
flute
fluted
fluting
flutter
fluttered
fluttering
flutters
fly
flier
fliers
flying
flies
flyable
flyer
flyer's
flyers
foam
foamed
foaming
foams
focal
focally
foci
focus
focused
focusing
focuses
fodder
foe
foe's
foes
fog
fog's
fogs
fogged
foggily
fogging
foggy
foggiest
foggier
foil
foiled
foiling
foils
fold
folded
folder
folders
folding
folds
foliage
folk
folk's
folks
folklore
follow
followed
follower
followers
following
followings
follows
folly
follies
fond
fondness
fonder
fondly
fondle
fondled
fondling
fondles
font
font's
fonts
food
food's
foods
foodstuff
foodstuff's
foodstuffs
fool
fooled
fooling
fools
foolish
foolishness
foolishly
foolproof
foot
footed
footer
footers
footing
football
football's
footballs
foothold
footman
footnote
footnote's
footnotes
footprint
footprint's
footprints
footstep
footsteps
for
forth
forage
foraged
foraging
forages
foray
foray's
forays
forbade
forbear
forbear's
forbears
forbearance
forbid
forbids
forbidden
forbidding
force
forced
forcer
force's
forcing
forces
forceful
forcefulness
forcefully
forcible
forcibly
ford
fords
fore
forest
forearm
forearm's
forearms
foreboding
forecast
forecasted
forecaster
forecasters
forecasting
forecasts
forecastle
forefather
forefather's
forefathers
forefinger
forefinger's
forefingers
forego
foregoing
foregoes
foregone
foreground
forehead
forehead's
foreheads
foreign
foreigner
foreigners
foreigns
foreman
foremost
forenoon
foresee
foresees
foreseeable
foreseen
foresight
foresighted
forest
forested
forester
foresters
forests
forestall
forestalled
forestalling
forestalls
forestallment
foretell
foretelling
foretells
foretold
forever
forewarn
forewarned
forewarning
forewarnings
forewarns
forfeit
forfeited
forgave
forge
forged
forger
forging
forges
forgery
forgery's
forgeries
forget
forgets
forgetful
forgetfulness
forgettable
forgettably
forgetting
forgivable
forgivably
forgive
forgiveness
forgiving
forgives
forgiven
forgivingly
forgot
forgotten
fork
forked
forking
forks
forlorn
forlornly
form
formed
former
forming
forms
formal
formally
formalism
formalism's
formalisms
formality
formalities
formalization
formalization's
formalizations
formalize
formalized
formalizing
formalizes
formant
formants
format
formative
formats
formation
formation's
formations
formatively
formatted
formatter
formatter's
formatters
formatting
formerly
formidable
formula
formula's
formulas
formulae
formulate
formulated
formulating
formulation
formulations
formulates
formulator
formulator's
formulators
fornication
forsake
forsaking
forsakes
forsaken
fort
fort's
forts
forte
forthcoming
forthwith
fortify
fortified
fortifying
fortification
fortifications
fortifies
fortitude
fortnight
fortnightly
FORTRAN
fortress
fortress's
fortresses
fortuitous
fortuitously
fortunate
fortunately
fortune
fortune's
fortunes
forty
fortier
fortieth
forties
forum
forum's
forums
forward
forwardness
forwarded
forwarder
forwarding
forwards
fossil
foster
fostered
fostering
fosters
fought
foul
foulness
fouled
foulest
fouling
foully
fouls
found
founded
founder
founders
founding
founds
foundation
foundation's
foundations
foundered
foundry
foundry's
foundries
fount
fount's
founts
fountain
fountain's
fountains
four
fourth
fours
fourier
fourscore
fourteen
fourteenth
fourteens
fowl
fowler
fowls
fox
fox's
foxes
fraction
fraction's
fractions
fractional
fractionally
fracture
fractured
fracturing
fractures
fragile
fragment
fragmented
fragmenting
fragments
fragmentary
fragrance
fragrance's
fragrances
fragrant
fragrantly
frail
frailest
frailty
frame
framed
framer
framing
frames
framework
framework's
frameworks
franc
francs
France
France's
Frances
franchise
franchise's
franchises
frank
frankness
franked
frankest
franker
franking
frankly
franks
frantic
frantically
fraternal
fraternally
fraternity
fraternity's
fraternities
fraud
fraud's
frauds
fraught
fray
frayed
fraying
frays
freak
freak's
freaks
freckle
freckled
freckles
free
freeness
freed
freest
freer
freely
frees
freedom
freedom's
freedoms
freeing
freeings
freeman
freeze
freezer
freezers
freezing
freezes
freight
freighted
freighter
freighters
freighting
freights
French
frenzy
frenzied
frequency
frequencies
frequent
frequented
frequenter
frequenters
frequenting
frequently
frequents
fresh
freshness
freshest
fresher
freshens
freshly
freshen
freshened
freshener
fresheners
freshening
freshens
freshman
freshmen
fret
fretful
fretfulness
fretfully
friar
friar's
friars
fricative
fricatives
friction
friction's
frictions
frictionless
Friday
Friday's
Fridays
friend
friend's
friends
friendless
friendly
friendliness
friendliest
friendlier
friendship
friendship's
friendships
frieze
frieze's
friezes
frigate
frigate's
frigates
fright
frightens
frighten
frightened
frightening
frightens
frighteningly
frightful
frightfulness
frightfully
frill
frill's
frills
fringe
fringed
frisk
frisked
frisking
frisks
frivolous
frivolously
frock
frock's
frocks
frog
frog's
frogs
frolic
frolics
from
front
fronted
fronting
fronts
frontier
frontier's
frontiers
frost
frosted
frosting
frosts
frosty
froth
frothing
frown
frowned
frowning
frowns
froze
frozen
frozenly
frugal
frugally
fruit
fruit's
fruits
fruitful
fruitfulness
fruitfully
fruition
fruitless
fruitlessly
frustrate
frustrated
frustrating
frustration
frustrations
frustrates
fry
fried
frication
fries
fuel
fueled
fueling
fuels
fugitive
fugitive's
fugitives
fulfill
fulfilled
fulfilling
fulfills
fulfillment
fulfillments
full
fullness
fullest
fuller
fully
fumble
fumbled
fumbling
fume
fumed
fuming
fumes
fun
function
functioned
function's
functioning
functions
functional
functionally
functionals
functionality
functionalities
functor
functor's
functors
fund
funded
funder
funders
funding
funds
fundamental
fundamentally
fundamentals
funeral
funeral's
funerals
fungus
funnel
funneled
funneling
funnels
funnily
funny
funniness
funniest
funnier
fur
fur's
furs
furious
furiouser
furiously
furnace
furnace's
furnaces
furnish
furnished
furnishing
furnishings
furnishes
furniture
furrow
furrowed
furrows
further
furthered
furthering
furthers
furthermore
furtive
furtiveness
furtively
fury
fury's
furies
fuse
fused
fusing
fusion
fuses
fuss
fussing
futile
futility
future
future's
futures
fuzzy
fuzziness
fuzzier
gabardine
gable
gabled
gabler
gables
gad
gadget
gadget's
gadgets
gag
gaging
gags
gagged
gagging
gaiety
gaieties
gaily
gain
gained
gainer
gainers
gaining
gains
gait
gaited
gaiter
gaiters
galaxy
galaxy's
galaxies
gale
gall
galled
galling
galls
gallant
gallantly
gallants
gallantry
gallery
galleried
galleries
galley
galley's
galleys
gallon
gallon's
gallons
gallop
galloped
galloper
galloping
gallops
gallows
gamble
gambled
gambler
gamblers
gambling
gambles
game
gameness
gamed
gaming
gamely
games
gamma
gang
gang's
gangs
gangrene
gangster
gangster's
gangsters
gap
gap's
gaps
gape
gaped
gaping
gapes
garage
garaged
garages
garb
garbed
garbage
garbage's
garbages
garden
gardened
gardener
gardeners
gardening
gardens
gargle
gargled
gargling
gargles
garland
garlanded
garlic
garment
garment's
garments
garner
garnered
garnish
garrison
garrisoned
garter
garter's
garters
gas
gas's
gases
gaseous
gaseously
gash
gash's
gashes
gasoline
gasp
gasped
gasping
gasps
gassed
gasser
gassing
gassings
gastric
gastrointestinal
gate
gated
gating
gates
gateway
gateway's
gateways
gather
gathered
gatherer
gatherers
gathering
gatherings
gathers
gaudy
gaudiness
gauge
gauged
gauges
gaunt
gauntness
gauze
gave
gay
gayness
gayest
gayer
gayly
gayety
gaze
gazed
gazer
gazers
gazing
gazes
gcd
gear
geared
gearing
gears
geese
gel
gel's
gels
gelatin
gelled
gelling
gem
gem's
gems
gender
gender's
genders
gene
gene's
genes
general
generally
generals
generalist
generalist's
generalists
generality
generalities
generalization
generalization's
generalizations
generalize
generalized
generalizer
generalizers
generalizing
generalizes
generate
generated
generater
generating
generation
generations
generative
generates
generator
generator's
generators
generic
generically
generosity
generosity's
generosities
generous
generousness
generously
genetic
genetically
genial
genially
genius
genius's
geniuses
genre
genre's
genres
genteel
gentle
gentleness
gentlest
gentler
gentleman
gentlemanly
gentlewoman
gently
gentry
genuine
genuineness
genuinely
genus
geographic
geographical
geographically
geography
geological
geologist
geologist's
geologists
geometric
geometry
geometries
geranium
germ
germ's
germs
German
German's
Germans
germane
Germany
germinate
germinated
germinating
germination
germinates
gestalt
gesture
gestured
gesturing
gestures
get
gets
getter
getter's
getters
getting
ghastly
ghost
ghosted
ghostly
ghosts
giant
giant's
giants
gibberish
giddy
giddiness
gift
gifted
gifts
gig
gigantic
giggle
giggled
giggling
giggles
gild
gilded
gilding
gilds
gill
gill's
gills
gilt
gimmick
gimmick's
gimmicks
gin
gin's
gins
ginger
gingerly
gingerbread
gingham
ginghams
gipsy
gipsy's
gipsies
giraffe
giraffe's
giraffes
gird
girder
girder's
girders
girdle
girl
girl's
girls
girt
girth
give
giver
givers
giving
gives
given
glacial
glacier
glacier's
glaciers
glad
gladness
gladly
gladder
gladdest
glade
glamour
glance
glanced
glancing
glances
gland
gland's
glands
glare
glared
glaring
glares
glaringly
glass
glassed
glasses
glassy
glaze
glazed
glazer
glazing
glazes
gleam
gleamed
gleaming
gleams
glean
gleaned
gleaner
gleaning
gleanings
gleans
glee
glees
gleeful
gleefully
glen
glen's
glens
glide
glided
glider
gliders
glides
glimmer
glimmered
glimmering
glimmers
glimpse
glimpsed
glimpses
glint
glinted
glinting
glints
glisten
glistened
glistening
glistens
glitter
glittered
glittering
glitters
global
globally
globe
globe's
globes
globular
globularity
gloom
gloomily
gloomy
glorify
glorified
glorification
glorifies
glorious
gloriously
glory
glorying
glories
gloss
glossed
glossing
glosses
glossary
glossary's
glossaries
glossy
glottal
glove
gloved
glover
glovers
gloving
gloves
glow
glowed
glower
glowers
glowing
glows
glowingly
glue
glued
gluing
glues
gnat
gnat's
gnats
gnaw
gnawed
gnawing
gnaws
go
going
goings
goad
goaded
goal
goal's
goals
goat
goat's
goats
goatee
goatee's
goatees
gobble
gobbled
gobbler
gobblers
gobbles
goblet
goblet's
goblets
goblin
goblin's
goblins
god
god's
godly
gods
goddess
goddess's
goddesses
godlike
godmother
godmother's
godmothers
goes
gold
golding
golden
golds
goldenly
goldenness
goldsmith
golf
golfer
golfers
golfing
gone
goner
gong
gong's
gongs
good
goodness
goodly
goods
goody
goody's
goodies
goose
gore
gorge
gorging
gorges
gorgeous
gorgeously
gorilla
gorilla's
gorillas
gosh
gospel
gospelers
gospels
gossip
gossiped
gossiping
gossips
got
Gothic
goto
gotten
gouge
gouged
gouging
gouges
govern
governed
governing
governs
governess
government
government's
governments
governmental
governmentally
governor
governor's
governors
gown
gowned
gowns
grab
grabs
grabbed
grabber
grabber's
grabbers
grabbing
grabbings
grace
graced
gracing
graces
graceful
gracefulness
gracefully
gracious
graciousness
graciously
gradation
gradation's
gradations
grade
graded
grader
graders
grading
gradings
grades
gradient
gradient's
gradients
gradual
gradually
graduate
graduated
graduating
graduation
graduations
graduates
graft
grafted
grafter
grafting
grafts
graham
graham's
grahams
grain
grained
graining
grains
gram
grams
grammar
grammar's
grammars
grammatical
grammatically
granary
granary's
granaries
grand
grandness
grandest
grander
grandly
grands
grandeur
grandfather
grandfather's
grandfathers
grandiose
grandma
grandmother
grandmother's
grandmothers
grandpa
grandson
grandson's
grandsons
grange
granite
granny
grant
granted
granter
granting
grants
granularity
granulate
granulated
granulating
granulates
grape
grape's
grapes
graph
graphed
graph's
graphing
graphic
graphics
graphical
graphically
graphite
graphs
grapple
grappled
grappling
grasp
grasped
grasping
grasps
graspable
grasping
graspingly
grass
grassed
grassers
grasses
grassy
grassiest
grassier
grate
grated
grater
grating
gratings
grates
grateful
gratefulness
gratefully
gratify
gratified
gratifying
gratification
gratitude
gratuitous
gratuitousness
gratuitously
gratuity
gratuity's
gratuities
grave
graveness
gravest
graver
gravely
graves
gravel
gravelly
gravitation
gravitational
gravity
gravy
gray
grayness
grayed
grayest
grayer
graying
graze
grazed
grazer
grazing
grease
greased
greases
greasy
great
greatness
greatest
greater
greatly
greed
greedily
greedy
greediness
Greek
Greek's
Greeks
green
greenness
greenest
greener
greening
greenly
greens
greenhouse
greenhouse's
greenhouses
greenish
greet
greeted
greeter
greeting
greetings
greets
grenade
grenade's
grenades
grew
grey
greyest
greying
grid
grid's
grids
grief
grief's
griefs
grievance
grievance's
grievances
grieve
grieved
griever
grievers
grieving
grieves
grievingly
grievous
grievously
grill
grilled
grilling
grills
grim
grimness
grimed
grimly
grin
grins
grind
grinder
grinders
grinding
grindings
grinds
grindstone
grindstone's
grindstones
grip
griped
griping
grips
gripe
griped
griping
gripes
gripped
gripping
grippingly
grit
grit's
grits
grizzly
groan
groaned
groaner
groaners
groaning
groans
grocer
grocer's
grocers
grocery
groceries
groom
groomed
grooming
grooms
groove
grooved
grooves
grope
groped
groping
gropes
gross
grossness
grossed
grossest
grosser
grossing
grossly
grosses
grotesque
grotesquely
grotesques
grotto
grotto's
grottos
ground
grounded
grounder
grounders
grounding
grounds
groundwork
group
grouped
grouping
groupings
groups
grouse
grove
grover
grovers
groves
grovel
groveled
groveling
grovels
grow
grower
growers
growing
growth
grows
growl
growled
growling
growls
grown
grownup
grownup's
grownups
growths
grub
grub's
grubs
grudge
grudge's
grudges
gruesome
gruff
gruffly
grumble
grumbled
grumbling
grumbles
grunt
grunted
grunting
grunts
guarantee
guaranteed
guaranteer
guaranteers
guarantees
guaranteeing
guaranty
guard
guarded
guarding
guards
guardedly
guardian
guardian's
guardians
guardianship
guerrilla
guerrilla's
guerrillas
guess
guessed
guessing
guesses
guest
guest's
guests
guidance
guide
guided
guiding
guides
guidebook
guidebook's
guidebooks
guideline
guideline's
guidelines
guild
guilder
guile
guilt
guiltily
guiltless
guiltlessly
guilty
guiltiness
guiltiest
guiltier
guinea
guise
guise's
guises
guitar
guitar's
guitars
gulch
gulch's
gulches
gulf
gulf's
gulfs
gull
gulled
gulling
gulls
gully
gully's
gullies
gulp
gulped
gulps
gum
gum's
gums
gun
gun's
guns
gunfire
gunned
gunner
gunner's
gunners
gunning
gunpowder
gurgle
gush
gushed
gusher
gushing
gushes
gust
gust's
gusts
gut
guts
gutter
guttered
gutters
guy
guyed
guying
guys
guyer
guyers
gymnasium
gymnasium's
gymnasiums
gymnast
gymnast's
gymnasts
gymnastic
gymnastics
gypsy
gypsy's
gypsies
gyroscope
gyroscope's
gyroscopes
ha
habit
habit's
habits
habitat
habitat's
habitats
habitation
habitation's
habitations
habitual
habitualness
habitually
hack
hacked
hacker
hackers
hacking
hacks
had
hadn't
hag
haggard
haggardly
hail
hailed
hailing
hails
hair
hair's
hairs
haircut
haircut's
haircuts
hairdryer
hairdryer's
hairdryers
hairless
hairy
hairiness
hairier
hale
haler
half
halfway
hall
hall's
halls
hallmark
hallmark's
hallmarks
hallow
hallowed
hallway
hallway's
hallways
halt
halted
halter
halters
halting
halts
haltingly
halve
halved
halvers
halving
halves
ham
ham's
hams
hamburger
hamburger's
hamburgers
Hamlet
Hamlet's
hamlets
hammer
hammered
hammering
hammers
hammock
hammock's
hammocks
hamper
hampered
hampers
hand
handed
handing
hands
handbag
handbag's
handbags
handbook
handbook's
handbooks
handcuff
handcuffed
handcuffing
handcuffs
handful
handfuls
handicap
handicap's
handicaps
handicapped
handily
handiwork
handkerchief
handkerchief's
handkerchiefs
handle
handled
handler
handlers
handling
handles
handsome
handsomeness
handsomest
handsomer
handsomely
handwriting
handwritten
handy
handiness
handiest
handier
hang
hanged
hanger
hangers
hanging
hangs
hangar
hangar's
hangars
hangover
hangover's
hangovers
hap
haply
haphazard
haphazardness
haphazardly
hapless
haplessness
haplessly
happen
happened
happening
happenings
happens
happily
happy
happiness
happiest
happier
harass
harassed
harassing
harasses
harassment
harbor
harbored
harboring
harbors
hard
hardness
hardest
harder
harden
hardly
hardship
hardship's
hardships
hardware
hardwired
hardy
hardiness
hare
hare's
hares
hark
harken
harlot
harlot's
harlots
harm
harmed
harming
harms
harmful
harmfulness
harmfully
harmless
harmlessness
harmlessly
harmonious
harmoniousness
harmoniously
harmonize
harmony
harmonies
harness
harnessed
harnessing
harp
harper
harpers
harping
harrow
harrowed
harrowing
harrows
harry
harried
harrier
harsh
harshness
harsher
harshly
hart
harvest
harvested
harvester
harvesting
harvests
has
hash
hashed
hasher
hashing
hashes
hasn't
haste
hastings
hasten
hastened
hastening
hastens
hastily
hasty
hastiness
hat
hat's
hats
hatch
hatched
hatching
hatchet
hatchet's
hatchets
hate
hated
hater
hating
hates
hateful
hatefulness
hatefully
hatred
haughtily
haughty
haughtiness
haul
hauled
hauler
hauling
hauls
haunch
haunch's
haunches
haunt
haunted
haunter
haunting
haunts
have
having
haves
haven
haven's
havens
haven't
havoc
hawk
hawked
hawker
hawkers
hawks
hay
haying
hays
hazard
hazard's
hazards
hazardous
haze
haze's
hazes
hazel
hazy
haziness
he
he's
hive
he'd
he'll
head
headed
header
headers
heading
heads
headache
headache's
headaches
headgear
heading
heading's
headings
headland
headland's
headlands
headline
headlined
headlining
headlines
headlong
headquarters
headway
heal
healed
healer
healers
healing
health
heals
healthful
healthfulness
healthfully
healthily
healthy
healthiness
healthiest
healthier
heap
heaped
heaping
heaps
hear
hearer
hearers
hearing
hearth
hearings
hears
heard
hearken
hearsay
heart
hearten
hearts
heartily
heartless
hearty
heartiness
heartiest
heat
heated
heater
heaters
heating
heats
heatable
heatedly
heath
heather
heathen
heave
heaved
heaver
heavers
heaving
heaves
heaven
heavenly
heavens
heavily
heavy
heaviness
heaviest
heavier
hedge
hedged
hedges
hedgehog
hedgehog's
hedgehogs
heed
heeded
heeds
heedless
heedlessness
heedlessly
heel
heeled
heelers
heeling
heels
heifer
height
heightens
heights
heighten
heightened
heightening
heightens
heinous
heinously
heir
heir's
heirs
heiress
heiress's
heiresses
held
hell
hell's
hells
hello
helm
helmet
helmet's
helmets
help
helped
helper
helpers
helping
helps
helpful
helpfulness
helpfully
helpless
helplessness
helplessly
hem
hem's
hems
hemisphere
hemisphere's
hemispheres
hemlock
hemlock's
hemlocks
hemostat
hemostats
hemp
hempen
hen
hen's
hens
hence
henceforth
henchman
henchmen
her
hers
herald
heralded
heralding
heralds
herb
herb's
herbs
herbivore
herbivorous
herd
herded
herder
herding
herds
here
here's
heres
hereabout
hereabouts
hereafter
hereby
hereditary
heredity
herein
hereinafter
heresy
heretic
heretic's
heretics
heretofore
herewith
heritage
heritages
hermit
hermit's
hermits
hero
heroes
heroic
heroics
heroically
heroin
heroine
heroine's
heroines
heroism
heron
heron's
herons
herring
herring's
herrings
herself
hesitant
hesitantly
hesitate
hesitated
hesitating
hesitation
hesitations
hesitates
hesitatingly
heterogeneous
heterogeneousness
heterogeneously
heuristic
heuristic's
heuristics
heuristically
hew
hewed
hewer
hews
hex
hexagonal
hexagonally
hey
hickory
hid
hidden
hide
hiding
hides
hideous
hideousness
hideously
hideout
hideout's
hideouts
hierarchical
hierarchically
hierarchy
hierarchy's
hierarchies
high
highest
higher
highly
highland
highlander
highlands
highlight
highlighted
highlighting
highlights
highness
highness's
highnesses
highway
highway's
highways
hike
hiked
hiker
hiking
hikes
hilarious
hilariously
hill
hill's
hills
hillock
hillside
hilltop
hilltop's
hilltops
hilt
hilt's
hilts
him
himself
hind
hinder
hinders
hindered
hindering
hindrance
hindrances
hindsight
hinge
hinged
hinges
hint
hinted
hinting
hints
hip
hip's
hips
hire
hired
hirer
hirers
hiring
hirings
hires
his
hiss
hissed
hissing
hisses
histogram
histogram's
histograms
historian
historian's
historians
historic
historical
historically
history
history's
histories
hit
hit's
hits
hitch
hitched
hitching
hitchhike
hitchhiked
hitchhiker
hitchhikers
hitchhiking
hitchhikes
hither
hitherto
hitter
hitter's
hitters
hitting
hoar
hoard
hoarder
hoarding
hoarse
hoarseness
hoarsely
hoary
hoariness
hobble
hobbled
hobbling
hobbles
hobby
hobby's
hobbies
hobbyist
hobbyist's
hobbyists
hockey
hoe
hoe's
hoes
hog
hog's
hogs
hoist
hoisted
hoisting
hoists
hold
holder
holders
holding
holden
holdings
holds
hole
holed
holes
holiday
holiday's
holidays
holistic
holland
hollow
hollowness
hollowed
hollowing
hollowly
hollows
holly
holocaust
hologram
hologram's
holograms
holy
holiness
holies
homage
home
homed
homer
homers
homing
homely
homes
homeless
homemade
homemaker
homemaker's
homemakers
homeomorphic
homeomorphism
homeomorphism's
homeomorphisms
homesick
homesickness
homespun
homestead
homesteader
homesteaders
homesteads
homeward
homewards
homework
homogeneity
homogeneity's
homogeneities
homogeneous
homogeneousness
homogeneously
homomorphic
homomorphism
homomorphism's
homomorphisms
hone
honed
honest
honer
honing
hones
honestly
honesty
honey
honeycomb
honeycombed
honeymoon
honeymooned
honeymooner
honeymooners
honeymooning
honeymoons
honeysuckle
honor
honored
honorer
honoring
honors
honorable
honorableness
honorably
honorary
honoraries
hood
hooded
hoods
hoodwink
hoodwinked
hoodwinking
hoodwinks
hoof
hoof's
hoofs
hook
hooked
hooker
hookers
hooking
hooks
hoop
hooper
hoops
hoot
hooted
hooter
hooting
hoots
hop
hops
hope
hoped
hoping
hopes
hopeful
hopefulness
hopefully
hopefuls
hopeless
hopelessness
hopelessly
hopper
hopper's
hoppers
horde
horde's
hordes
horizon
horizon's
horizons
horizontal
horizontally
hormone
hormone's
hormones
horn
horned
horns
hornet
hornet's
hornets
horrendous
horrendously
horrible
horribleness
horribly
horrid
horridly
horrify
horrified
horrifying
horrifies
horror
horror's
horrors
horse
horsely
horses
horseback
horseman
horsepower
horseshoe
horseshoer
hose
hose's
hoses
hospitable
hospitably
hospital
hospital's
hospitals
hospitality
hospitalize
hospitalized
hospitalizing
hospitalizes
host
hosted
hosting
hosts
hostage
hostage's
hostages
hostess
hostess's
hostesses
hostile
hostilely
hostility
hostilities
hot
hotness
hotly
hotel
hotel's
hotels
hotter
hottest
hound
hounded
hounding
hounds
hour
hourly
hours
house
housed
housing
houses
housefly
housefly's
houseflies
household
householder
householders
households
housekeeper
housekeeper's
housekeepers
housekeeping
housetop
housetop's
housetops
housewife
housewifely
housework
hovel
hovel's
hovels
hover
hovered
hovering
hovers
how
however
howl
howled
howler
howling
howls
hub
hub's
hubs
hubris
huddle
huddled
huddling
hue
hue's
hues
hug
huge
hugeness
hugely
huh
hull
hull's
hulls
hum
hums
human
humanness
humanly
humans
humane
humaneness
humanely
humanity
humanity's
humanities
humble
humbleness
humbled
humblest
humbler
humbling
humbly
humid
humidly
humidify
humidified
humidifier
humidifiers
humidifying
humidification
humidifies
humidity
humiliate
humiliated
humiliating
humiliation
humiliations
humiliates
humility
hummed
humming
humor
humored
humorer
humorers
humoring
humors
humorous
humorousness
humorously
hump
humped
hunch
hunched
hunches
hundred
hundredth
hundreds
hung
hunger
hungers
hunger
hungered
hungering
hungrily
hungry
hungriest
hungrier
hunk
hunk's
hunks
hunt
hunted
hunter
hunters
hunting
hunts
huntsman
hurl
hurled
hurler
hurlers
hurling
hurrah
hurricane
hurricane's
hurricanes
hurriedly
hurry
hurried
hurrying
hurries
hurt
hurting
hurts
husband
husband's
husbands
husbandry
hush
hushed
hushing
hushes
husk
husked
husker
husking
husks
husky
huskiness
hustle
hustled
hustler
hustling
hustles
hut
hut's
huts
hyacinth
hybrid
hydraulic
hydrodynamic
hydrodynamics
hydrogen
hydrogen's
hydrogens
hygiene
hymn
hymn's
hymns
hyperbolic
hyphen
hyphen's
hyphens
hypocrisy
hypocrisies
hypocrite
hypocrite's
hypocrites
hypodermic
hypodermics
hypotheses
hypothesis
hypothesize
hypothesized
hypothesizer
hypothesizing
hypothesizes
hypothetical
hypothetically
hysteresis
hysterical
hysterically
I'd
I'll
I'm
I've
ice
iced
icing
icings
ices
iceberg
iceberg's
icebergs
icy
iciness
idea
idea's
ideas
ideal
ideally
ideals
idealism
idealistic
idealization
idealization's
idealizations
idealize
idealized
idealizing
idealizes
identical
identically
identifiable
identifiably
identify
identified
identifier
identifiers
identifying
identification
identifications
identifies
identity
identity's
identities
ideological
ideologically
ideology
idiosyncrasy
idiosyncrasy's
idiosyncrasies
idiosyncratic
idiot
idiot's
idiots
idiotic
idle
idleness
idled
idlest
idler
idling
idles
idlers
idly
idol
idol's
idols
idolatry
if
ignition
ignoble
ignorance
ignorant
ignorantly
ignore
ignored
ignoring
ignores
ill
ills
illegal
illegally
illegality
illegalities
illicit
illicitly
Illinois
illiterate
illness
illness's
illnesses
illogical
illogically
illuminate
illuminated
illuminating
illumination
illuminations
illuminates
illusion
illusion's
illusions
illusive
illusively
illustrate
illustrated
illustrating
illustration
illustrations
illustrative
illustrates
illustratively
illustrator
illustrator's
illustrators
illustrious
illustriousness
illy
image
imaging
images
imaginable
imaginably
imaginary
imagination
imagination's
imaginations
imaginative
imaginatively
imagine
imagined
imagining
imaginings
imagines
imbalance
imbalances
imitate
imitated
imitating
imitation
imitations
imitative
imitates
immaculate
immaculately
immaterial
immaterially
immature
immaturity
immediacy
immediacies
immediate
immediately
immemorial
immense
immensely
immerse
immersed
immersion
immerses
immigrant
immigrant's
immigrants
immigrate
immigrated
immigrating
immigration
immigrates
imminent
imminently
immortal
immortally
immortality
immovability
immovable
immovably
immune
immunity
immunity's
immunities
immutable
imp
impact
impacted
impacting
impacts
impaction
impactor
impactor's
impactors
impair
impaired
impairing
impairs
impart
imparted
imparts
impartial
impartially
impasse
impassive
impatience
impatient
impatiently
impeach
impedance
impedance's
impedances
impede
impeded
impeding
impedes
impediment
impediment's
impediments
impel
impending
impenetrability
impenetrable
impenetrably
imperative
imperatively
imperatives
imperfect
imperfectly
imperfection
imperfection's
imperfections
imperial
imperialism
imperialist
imperialist's
imperialists
imperil
imperiled
imperious
imperiously
impermanence
impermanent
impermissible
impersonal
impersonally
impersonate
impersonated
impersonating
impersonation
impersonations
impersonates
impertinent
impertinently
impervious
imperviously
impetuous
impetuously
impetus
impinge
impinged
impinging
impinges
impious
implant
implanted
implanting
implants
implausible
implement
implemented
implementing
implements
implementable
implementation
implementation's
implementations
implementor
implementor's
implementors
implicant
implicant's
implicants
implicate
implicated
implicating
implication
implications
implicates
implicit
implicitness
implicitly
implore
implored
imploring
imply
implied
implying
implication
implications
implies
import
imported
importer
importers
importing
imports
importance
important
importantly
importation
impose
imposed
imposing
imposes
imposition
imposition's
impositions
impossibility
impossibilities
impossible
impossibly
impostor
impostor's
impostors
impotence
impotent
impoverish
impoverished
impoverishment
impracticable
impractical
impractically
impracticality
imprecise
imprecision
imprecisely
impregnable
impress
impressed
impresser
impressing
impressive
impresses
impression
impression's
impressions
impressionable
impressionist
impressionistic
impressive
impressiveness
impressively
impressment
imprint
imprinted
imprinting
imprints
imprison
imprisoned
imprisoning
imprisons
imprisonment
imprisonment's
imprisonments
improbable
impromptu
improper
improperly
improve
improved
improving
improves
improvement
improvements
improvisation
improvisation's
improvisations
improvisational
improvise
improvised
improviser
improvisers
improvising
improvises
impudent
impudently
impulse
impulsion
impulsive
impulses
impunity
impure
impurity
impurity's
impurities
impute
imputed
in
inability
inaccessible
inaccuracy
inaccuracies
inaccurate
inactive
inactivity
inadequacy
inadequacies
inadequate
inadequateness
inadequately
inadmissibility
inadvertent
inadvertently
inadvisable
inanimate
inanimately
inappropriate
inappropriateness
inasmuch
inaugural
inaugurate
inaugurated
inaugurating
inauguration
incapable
incapacitating
incarnation
incarnation's
incarnations
incendiary
incendiaries
incense
incensed
incenses
incentive
incentive's
incentives
inception
incessant
incessantly
inch
inched
inching
inches
incidence
incident
incident's
incidents
incidental
incidentally
incidentals
incipient
incite
incited
inciting
incites
inclination
inclination's
inclinations
incline
inclined
inclining
inclines
inclose
inclosed
inclosing
incloses
include
included
including
includes
inclusion
inclusion's
inclusions
inclusive
inclusiveness
inclusively
incoherent
incoherently
income
incoming
incomes
incommensurate
incomparable
incomparably
incompatibility
incompatibility's
incompatibilities
incompatible
incompatibly
incompetence
incompetent
incompetent's
incompetents
incomplete
incompleteness
incompletely
incomprehensibility
incomprehensible
incomprehensibly
inconceivable
inconclusive
inconsequential
inconsequentially
inconsiderate
inconsiderateness
inconsiderately
inconsistency
inconsistency's
inconsistencies
inconsistent
inconsistently
inconvenience
inconvenienced
inconveniencing
inconveniences
inconvenient
inconveniently
incorporate
incorporated
incorporating
incorporation
incorporates
incorrect
incorrectness
incorrectly
increase
increased
increasing
increases
increasingly
incredible
incredibly
incredulous
incredulously
increment
incremented
incrementing
increments
incremental
incrementally
incubate
incubated
incubating
incubation
incubates
incubator
incubator's
incubators
incur
incurs
incurable
incurred
incurring
indebted
indebtedness
indecision
indeed
indefinite
indefiniteness
indefinitely
indemnity
indent
indented
indenting
indents
indentation
indentation's
indentations
independence
independent
independently
independents
indescribable
indeterminacy
indeterminacy's
indeterminacies
indeterminate
indeterminately
index
indexed
indexing
indexes
indexable
India
Indian
Indian's
Indians
Indiana
indicate
indicated
indicating
indication
indications
indicative
indicates
indicator
indicator's
indicators
indices
indictment
indictment's
indictments
indifference
indifferent
indifferently
indigenous
indigenousness
indigenously
indigestion
indignant
indignantly
indignation
indignity
indignities
indigo
indirect
indirected
indirecting
indirectly
indirects
indirection
indirections
indiscriminate
indiscriminately
indispensability
indispensable
indispensably
indistinguishable
individual
individual's
individually
individuals
individualistic
individuality
individualize
individualized
individualizing
individualizes
indivisibility
indivisible
indoctrinate
indoctrinated
indoctrinating
indoctrination
indoctrinates
indolent
indolently
indomitable
indoor
indoors
induce
induced
inducer
inducing
induces
inducement
inducement's
inducements
induct
inducted
inducting
inducts
inductance
inductances
induction
induction's
inductions
inductive
inductively
inductor
inductor's
inductors
indulge
indulged
indulging
indulgence
indulgence's
indulgences
industrial
industrially
industrials
industrialist
industrialist's
industrialists
industrialization
industrious
industriousness
industriously
industry
industry's
industries
ineffective
ineffectiveness
ineffectively
inefficiency
inefficiencies
inefficient
inefficiently
inelegant
inequality
inequalities
inert
inertness
inertly
inertia
inescapable
inescapably
inessential
inestimable
inevitability
inevitabilities
inevitable
inevitably
inexact
inexcusable
inexcusably
inexorable
inexorably
inexpensive
inexpensively
inexperience
inexperienced
inexplicable
infallibility
infallible
infallibly
infamous
infamously
infancy
infant
infant's
infants
infantry
infeasible
infect
infected
infecting
infective
infects
infection
infection's
infections
infectious
infectiously
infer
infers
inference
inference's
inferences
inferential
inferior
inferior's
inferiors
inferiority
infernal
infernally
inferno
inferno's
infernos
inferred
inferring
infest
infested
infesting
infests
infidel
infidel's
infidels
infinite
infiniteness
infinitely
infinitesimal
infinitive
infinitive's
infinitives
infinitum
infinity
infirmity
infix
inflame
inflamed
inflammable
inflatable
inflate
inflated
inflating
inflation
inflates
inflationary
inflexibility
inflexible
inflict
inflicted
inflicting
inflicts
influence
influenced
influencing
influences
influential
influentially
influenza
inform
informed
informer
informers
informing
informs
informal
informally
informality
informant
informant's
informants
information
informational
informative
informatively
infrequent
infrequently
infringe
infringed
infringing
infringes
infringement
infringement's
infringements
infuriate
infuriated
infuriating
infuriation
infuriates
infuse
infused
infusing
infusion
infusions
infuses
ingenious
ingeniousness
ingeniously
ingenuity
ingratitude
ingredient
ingredient's
ingredients
inhabit
inhabited
inhabiting
inhabits
inhabitable
inhabitance
inhabitant
inhabitant's
inhabitants
inhale
inhaled
inhaler
inhaling
inhales
inhere
inheres
inherent
inherently
inherit
inherited
inheriting
inherits
inheritable
inheritance
inheritance's
inheritances
inheritor
inheritor's
inheritors
inheritress
inheritress's
inheritresses
inheritrices
inheritrix
inhibit
inhibited
inhibiting
inhibits
inhibition
inhibition's
inhibitions
inhibitors
inhomogeneity
inhomogeneities
inhuman
inhumane
iniquity
iniquity's
iniquities
initial
initialed
initialing
initially
initials
initialization
initialization's
initializations
initialize
initialized
initializer
initializers
initializing
initializes
initiate
initiated
initiating
initiation
initiations
initiative
initiates
initiative
initiative's
initiatives
initiator
initiator's
initiators
inject
injected
injecting
injective
injects
injection
injection's
injections
injunction
injunction's
injunctions
injure
injured
injuring
injures
injurious
injury
injury's
injuries
injustice
injustice's
injustices
ink
inked
inker
inkers
inking
inkings
inks
inkling
inkling's
inklings
inlaid
inland
inlet
inlet's
inlets
inline
inmate
inmate's
inmates
inn
inner
inning
innings
inns
innards
innate
innately
innermost
innocence
innocent
innocently
innocents
innocuous
innocuousness
innocuously
innovate
innovation
innovations
innovative
innovation
innovation's
innovations
innumerability
innumerable
innumerably
inordinate
inordinately
input
input's
inputs
inquire
inquired
inquirer
inquirers
inquiring
inquires
inquiry
inquiry's
inquiries
inquisition
inquisition's
inquisitions
inquisitive
inquisitiveness
inquisitively
inroad
inroads
insane
insanely
insanity
inscribe
inscribed
inscribing
inscribes
inscription
inscription's
inscriptions
insect
insect's
insects
insecure
insecurely
insensible
insensitive
insensitively
insensitivity
inseparable
insert
inserted
inserting
inserts
insertion
insertion's
insertions
inside
insider
insiders
insides
insidious
insidiousness
insidiously
insight
insight's
insights
insignia
insignificance
insignificant
insinuate
insinuated
insinuating
insinuation
insinuations
insinuates
insist
insisted
insisting
insists
insistence
insistent
insistently
insofar
insolence
insolent
insolently
inspect
inspected
inspecting
inspects
inspection
inspection's
inspections
inspector
inspector's
inspectors
inspiration
inspiration's
inspirations
inspire
inspired
inspirer
inspiring
inspires
instability
instabilities
install
installed
installer
installers
installing
installs
installation
installation's
installations
installment
installment's
installments
instance
instances
instant
instanter
instantly
instants
instantaneous
instantaneously
instantiate
instantiated
instantiating
instantiation
instantiations
instantiates
instantiation
instantiation's
instantiations
instead
instigate
instigated
instigating
instigates
instigator
instigator's
instigators
instinct
instinct's
instinctive
instincts
instinctively
institute
instituted
instituter
instituters
instituting
institution
institutions
institutes
institutional
institutionally
institutionalize
institutionalized
institutionalizing
institutionalizes
instruct
instructed
instructing
instructive
instructs
instruction
instruction's
instructions
instructional
instructively
instructor
instructor's
instructors
instrument
instrumented
instrumenting
instruments
instrumental
instrumentally
instrumentals
instrumentalist
instrumentalist's
instrumentalists
instrumentation
insufficient
insufficiently
insulate
insulated
insulating
insulation
insulates
insulator
insulator's
insulators
insult
insulted
insulting
insults
insuperable
insurance
insure
insured
insurer
insurers
insuring
insures
insurgent
insurgent's
insurgents
insurmountable
insurrection
insurrection's
insurrections
intact
intangible
intangible's
intangibles
integer
integer's
integers
integral
integral's
integrals
integrate
integrated
integrating
integration
integrations
integrative
integrates
integrity
intellect
intellect's
intellects
intellectual
intellectually
intellectuals
intelligence
intelligent
intelligently
intelligibility
intelligible
intelligibly
intend
intended
intending
intends
intense
intensive
intensely
intensify
intensified
intensifier
intensifiers
intensifying
intensification
intensifies
intensity
intensities
intensively
intent
intentness
intently
intents
intention
intentioned
intentions
intentional
intentionally
interact
interacted
interacting
interactive
interacts
interaction
interaction's
interactions
interactively
interactivity
intercept
intercepted
intercepting
intercepts
interchange
interchanged
interchanging
interchangings
interchanges
interchangeability
interchangeable
interchangeably
intercity
intercommunicate
intercommunicated
intercommunicating
intercommunication
intercommunicates
interconnect
interconnected
interconnecting
interconnects
interconnection
interconnection's
interconnections
intercourse
interdependence
interdependency
interdependencies
interdependent
interdisciplinary
interest
interested
interesting
interests
interestingly
interface
interfaced
interfacer
interfacing
interfaces
interfere
interfered
interfering
interferes
interference
interferences
interferingly
interim
interior
interior's
interiors
interlace
interlaced
interlacing
interlaces
interleave
interleaved
interleaving
interleaves
interlink
interlinked
interlinks
intermediary
intermediate
intermediate's
intermediates
interminable
intermingle
intermingled
intermingling
intermingles
intermittent
intermittently
intermodule
intern
interned
interns
internal
internally
internals
internalize
internalized
internalizing
internalizes
international
internationally
internationality
interpersonal
interplay
interpolate
interpolated
interpolating
interpolation
interpolations
interpolates
interpose
interposed
interposing
interposes
interpret
interpreted
interpreter
interpreters
interpreting
interpretive
interprets
interpretable
interpretation
interpretation's
interpretations
interpretively
interprocess
interrelate
interrelated
interrelating
interrelation
interrelations
interrelates
interrelationship
interrelationship's
interrelationships
interrogate
interrogated
interrogating
interrogation
interrogations
interrogative
interrogates
interrupt
interrupted
interrupting
interruptive
interrupts
interruptible
interruption
interruption's
interruptions
intersect
intersected
intersecting
intersects
intersection
intersection's
intersections
intersperse
interspersed
interspersing
interspersion
intersperses
interstage
interstate
intertwine
intertwined
intertwining
intertwines
interval
interval's
intervals
intervene
intervened
intervening
intervenes
intervention
intervention's
interventions
interview
interviewed
interviewer
interviewers
interviewing
interviews
interwoven
intestinal
intestine
intestine's
intestines
intimacy
intimate
intimated
intimating
intimation
intimations
intimately
intimidate
intimidated
intimidating
intimidation
intimidates
into
intolerable
intolerably
intolerance
intolerant
intonation
intonation's
intonations
intoxicate
intoxicated
intoxicating
intoxication
intractability
intractable
intractably
intramural
intransigent
intransitive
intransitively
intraprocess
intricacy
intricacies
intricate
intricately
intrigue
intrigued
intriguing
intrigues
intrinsic
intrinsically
introduce
introduced
introducing
introduces
introduction
introduction's
introductions
introductory
introspect
introspective
introspection
introspections
introvert
introverted
intrude
intruded
intruder
intruding
intrudes
intruder
intruder's
intruders
intrusion
intrusion's
intrusions
intrust
intubate
intubated
intubation
intubates
intuition
intuition's
intuitions
intuitionist
intuitive
intuitively
invade
invaded
invader
invaders
invading
invades
invalid
invalidly
invalids
invalidate
invalidated
invalidating
invalidation
invalidations
invalidates
invalidity
invalidities
invaluable
invariable
invariably
invariance
invariant
invariantly
invariants
invasion
invasion's
invasions
invent
invented
inventing
inventive
invents
invention
invention's
inventions
inventively
inventiveness
inventor
inventor's
inventors
inventory
inventory's
inventories
inverse
inversion
inversions
inversely
inverses
invert
inverted
inverter
inverters
inverting
inverts
invertebrate
invertebrate's
invertebrates
invertible
invest
invested
investing
invests
investigate
investigated
investigating
investigation
investigations
investigative
investigates
investigator
investigator's
investigators
investment
investment's
investments
investor
investor's
investors
invincible
invisibility
invisible
invisibly
invitation
invitation's
invitations
invite
invited
inviting
invites
invocable
invocation
invocation's
invocations
invoice
invoiced
invoicing
invoices
invoke
invoked
invoker
invoking
invokes
involuntarily
involuntary
involve
involved
involving
involves
involvement
involvement's
involvements
inward
inwardness
inwardly
inwards
iodine
ion
ions
irate
irateness
irately
ire
ire's
ires
ireland
ireland's
iris
irk
irked
irking
irks
irksome
iron
ironed
ironing
ironings
irons
ironical
ironically
irony
ironies
irrational
irrationally
irrationals
irrecoverable
irreducible
irreducibly
irreflexive
irrefutable
irregular
irregularly
irregulars
irregularity
irregularities
irrelevance
irrelevances
irrelevant
irrelevantly
irrepressible
irresistible
irrespective
irrespectively
irresponsible
irresponsibly
irreversible
irrigate
irrigated
irrigating
irrigation
irrigates
irritate
irritated
irritating
irritation
irritations
irritates
is
island
islander
islanders
islands
isle
isle's
isles
islet
islet's
islets
isn't
isolate
isolated
isolating
isolation
isolations
isolates
isometric
isomorphic
isomorphically
isomorphism
isomorphism's
isomorphisms
isotope
isotope's
isotopes
israel
issuance
issue
issued
issuer
issuers
issuing
issues
isthmus
it
it's
italian
italian's
italians
italic
italics
italicize
italicized
itch
itching
itches
item
item's
items
itemization
itemization's
itemizations
itemize
itemized
itemizing
itemizes
iterate
iterated
iterating
iteration
iterations
iterative
iterates
iterative
iteratively
iterator
iterator's
iterators
its
itself
ivory
ivy
ivy's
ivies
jab
jab's
jabs
jabbed
jabbing
jack
jacket
jacketed
jackets
jade
jaded
jail
jailed
jailer
jailers
jailing
jails
jam
jams
jammed
jamming
janitor
janitor's
janitors
January
January's
Januaries
Japan
Japanese
jar
jar's
jars
jargon
jarred
jarring
jarringly
jaunt
jaunt's
jaunts
jaunty
jauntiness
javelin
javelin's
javelins
jaw
jaw's
jaws
jay
jazz
jealous
jealously
jealousy
jealousies
jean
jean's
jeans
jeep
jeep's
jeeps
jeer
jeer's
jeers
jelly
jelly's
jellies
jellyfish
jenny
jeopardize
jeopardized
jeopardizing
jeopardizes
jerk
jerked
jerking
jerkings
jerks
jerky
jerkiness
jersey
jersey's
jerseys
jest
jested
jester
jesting
jests
jet
jet's
jets
jetted
jetting
jewel
jeweled
jeweler
jewels
jewelry
jewelries
jig
jig's
jigs
jill
jingle
jingled
jingling
job
job's
jobs
jocund
jog
jogs
join
joined
joiner
joiners
joining
joins
joint
joint's
jointly
joints
joke
joked
joker
jokers
joking
jokes
jolly
jolt
jolted
jolting
jolts
jostle
jostled
jostling
jostles
jot
jots
jotted
jotting
journal
journal's
journals
journalism
journalist
journalist's
journalists
journalize
journalized
journalizing
journalizes
journey
journeyed
journeying
journeyings
journeys
joust
jousted
jousting
jousts
joy
joy's
joys
joyful
joyfully
joyous
joyousness
joyously
jubilee
judge
judged
judging
judges
judgment
judgment's
judgments
judical
judicial
judiciary
judicious
judiciously
jug
jug's
jugs
juggle
juggler
jugglers
juggling
juggles
juice
juice's
juices
juicy
juiciest
July
July's
julies
jumble
jumbled
jumbles
jump
jumped
jumper
jumpers
jumping
jumps
jumpy
junction
junction's
junctions
juncture
juncture's
junctures
June
jungle
jungle's
jungles
junior
junior's
juniors
juniper
junk
junker
junkers
junks
jurisdiction
jurisdiction's
jurisdictions
juror
juror's
jurors
jury
jury's
juries
just
justness
justly
justice
justice's
justices
justifiable
justifiably
justifier's
justify
justified
justifier
justifiers
justifying
justification
justifications
justifies
jut
juvenile
juvenile's
juveniles
juxtapose
juxtaposed
juxtaposing
juxtaposes
keel
keeled
keeling
keels
keen
keenness
keenest
keener
keenly
keep
keeper
keepers
keeping
keeps
ken
kennel
kennel's
kennels
kept
kerchief
kerchief's
kerchiefs
kernel
kernel's
kernels
kerosene
ketchup
kettle
kettle's
kettles
key
keyed
keying
keys
keyboard
keyboard's
keyboards
keypad
keypad's
keypads
keystroke
keystroke's
keystrokes
keyword
keyword's
keywords
kick
kicked
kicker
kickers
kicking
kicks
kid
kid's
kids
kidded
kidding
kidnap
kidnaps
kidnapper
kidnapper's
kidnappers
kidnapping
kidnapping's
kidnappings
kidney
kidney's
kidneys
kill
killed
killer
killers
killing
killings
kills
killingly
kilogram
kilograms
kilometer
kilometers
kin
kind
kindness
kindest
kinder
kindly
kinds
kindergarten
kindhearted
kindle
kindled
kindling
kindles
kindred
king
kingly
kings
kingdom
kingdom's
kingdoms
kinship
kinsman
kiss
kissed
kisser
kissers
kissing
kisses
kit
kit's
kits
kitchen
kitchen's
kitchens
kite
kited
kiting
kites
kitten
kitten's
kittens
kitty
kludges
knack
knapsack
knapsack's
knapsacks
knave
knave's
knaves
knead
kneads
knee
kneed
knees
kneeing
kneel
kneeled
kneeling
kneels
knell
knell's
knells
knelt
knew
knickerbocker
knickerbocker's
knickerbockers
knife
knifed
knifing
knifes
knight
knighted
knighting
knightly
knights
knighthood
knit
knits
knives
knob
knob's
knobs
knock
knocked
knocker
knockers
knocking
knocks
knoll
knoll's
knolls
knot
knot's
knots
knotted
knotting
know
knower
knowing
knows
knowable
knowhow
knowingly
knowledgable
knowledge
knowledgeable
known
knuckle
knuckled
knuckles
lab
lab's
labs
label
labeled
labeler
labeling
labels
labor
labored
laborer
laborers
laboring
laborings
labors
laboratory
laboratory's
laboratories
laborious
laboriously
labyrinth
labyrinths
lace
laced
lacing
laces
lacerate
lacerated
lacerating
laceration
lacerations
lacerates
lack
lacked
lacking
lacks
lacquer
lacquered
lacquers
lad
lading
laden
lads
ladder
lady
lady's
ladies
lag
lager
lagers
lags
lagoon
lagoon's
lagoons
Lagrangian
laid
lain
lair
lair's
lairs
lake
lake's
lakes
lamb
lamb's
lambs
lambda
lame
lameness
lamed
laming
lamely
lames
lament
lamented
lamenting
laments
lamentable
lamentation
lamentation's
lamentations
laminar
lamp
lamp's
lamps
lance
lanced
lancer
lances
land
landed
lander
landers
landing
landings
lands
landlady
landlady's
landladies
landlord
landlord's
landlords
landmark
landmark's
landmarks
landowner
landowner's
landowners
landscape
landscaped
landscaping
landscapes
lane
lane's
lanes
language
language's
languages
languid
languidness
languidly
languish
languished
languishing
languishes
lantern
lantern's
lanterns
lap
lap's
laps
lapel
lapel's
lapels
lapse
lapsed
lapsing
lapses
lard
larder
large
largeness
largest
larger
largely
lark
lark's
larks
larva
larvae
laser
laser's
lasers
lash
lashed
lashing
lashings
lashes
lass
lass's
lasses
last
lasted
lasting
lastly
lasts
latch
latched
latching
latches
late
lateness
latest
later
lately
latency
latent
lateral
laterally
latitude
latitude's
latitudes
latrine
latrine's
latrines
latter
latterly
lattice
lattice's
lattices
laugh
laughed
laughing
laughable
laughably
laughingly
laughs
laughter
launch
launched
launcher
launching
launchings
launches
launder
laundered
launderer
laundering
launderings
launders
laundry
laurel
laurel's
laurels
lava
lavatory
lavatory's
lavatories
lavender
lavish
lavished
lavishing
lavishly
law
law's
laws
lawful
lawfully
lawless
lawlessness
lawn
lawn's
lawns
lawsuit
lawsuit's
lawsuits
lawyer
lawyer's
lawyers
lay
laying
lays
layer
layered
layering
layers
layman
laymen
layoffs
layout
layout's
layouts
lazed
lazily
lazing
lazy
laziness
laziest
lazier
lead
leaded
leader
leaders
leading
leaden
leadings
leads
leadership
leadership's
leaderships
leaf
leafed
leafing
leafless
leaflet
leaflet's
leaflets
leafy
leafiest
league
leagued
leaguer
leaguers
leagues
leak
leaked
leaking
leaks
leakage
leakage's
leakages
lean
leanness
leaned
leanest
leaner
leaning
leans
leap
leaped
leaping
leaps
leapt
learn
learned
learner
learners
learning
learns
lease
leased
leasing
leases
leash
leash's
leashes
least
leather
leathered
leathers
leathern
leave
leaved
leaving
leavings
leaves
leaven
leavened
leavening
lecture
lectured
lecturer
lecturers
lecturing
lectures
led
ledge
ledger
ledgers
ledges
lee
leer
lees
leech
leech's
leeches
left
leftist
leftist's
leftists
leftmost
leftover
leftover's
leftovers
leftward
leg
leger
legers
legs
legacy
legacy's
legacies
legal
legally
legality
legalization
legalize
legalized
legalizing
legalizes
legend
legend's
legends
legendary
legged
leggings
legibility
legible
legibly
legion
legion's
legions
legislate
legislated
legislating
legislation
legislative
legislates
legislator
legislator's
legislators
legislature
legislature's
legislatures
legitimacy
legitimate
legitimately
leisure
leisurely
lemma
lemma's
lemmas
lemon
lemon's
lemons
lemonade
lend
lender
lenders
lending
lends
length
lengthen
lengthly
lengthen
lengthened
lengthening
lengthens
lengths
lengthwise
lengthy
leniency
lenient
leniently
lens
lens's
lenses
lent
lenten
lentil
lentil's
lentils
leopard
leopard's
leopards
leprosy
less
lesser
lessen
lessened
lessening
lessens
lesson
lesson's
lessons
lest
lester
let
let's
lets
letter
lettered
letterer
lettering
letters
letting
lettuce
leukemia
levee
levee's
levees
level
levelness
leveled
leveler
leveling
levelly
levels
levelled
leveller
levellest
levelling
lever
lever's
levers
leverage
levy
levied
levying
levies
lewd
lewdness
lewdly
lexical
lexically
lexicographic
lexicographical
lexicographically
lexicon
lexicon's
lexicons
liability
liability's
liabilities
liable
liaison
liaison's
liaisons
liar
liar's
liars
liberal
liberally
liberals
liberalize
liberalized
liberalizing
liberalizes
liberate
liberated
liberating
liberation
liberates
liberator
liberator's
liberators
liberty
liberty's
liberties
libido
librarian
librarian's
librarians
library
library's
libraries
license
licensed
licensing
licenses
lichen
lichen's
lichens
lick
licked
licking
licks
lid
lid's
lids
lie
lied
lies
liege
lien
lien's
liens
lieu
lieutenant
lieutenant's
lieutenants
life
lifer
lifeless
lifelessness
lifelike
lifelong
lifestyle
lifestyles
lifetime
lifetime's
lifetimes
lift
lifted
lifter
lifters
lifting
lifts
light
lightness
lighted
lightest
lighting
lighten
lightens
lightly
lights
lighter
lighter's
lighters
lighthouse
lighthouse's
lighthouses
lightning
lightning's
lightnings
lightweight
like
liked
liking
likes
likelihood
likelihoods
likely
likeliness
likeliest
likelier
liken
likened
likening
likens
likeness
likeness's
likenesses
likewise
lilac
lilac's
lilacs
lily
lily's
lilies
limb
limber
limbs
lime
lime's
limes
limestone
limit
limited
limiter
limiters
limiting
limits
limitability
limitably
limitation
limitation's
limitations
limp
limpness
limped
limping
limply
limps
linden
line
lined
liner
liners
lining
linings
lines
line's
linear
linearly
linearity
linearities
linearizable
linearize
linearized
linearizing
linearizes
linen
linen's
linens
linger
lingered
lingering
lingers
linguist
linguist's
linguists
linguistic
linguistics
linguistically
link
linked
linker
linking
links
linkage
linkage's
linkages
linoleum
linseed
lion
lion's
lions
lioness
lioness's
lionesses
lip
lip's
lips
lipstick
liquid
liquid's
liquids
liquidation
liquidation's
liquidations
liquidity
liquify
liquified
liquifier
liquifiers
liquifying
liquifies
liquor
liquor's
liquors
lisp
lisped
lisp's
lisping
lisps
list
listed
lister
listers
listing
listens
lists
listen
listened
listener
listeners
listening
listens
listing
listing's
listings
lit
liter
liters
literacy
literal
literalness
literally
literals
literary
literate
literature
literature's
literatures
lithe
litter
littered
littering
litters
little
littleness
littlest
littler
livable
livably
live
liveness
lived
liver
livers
living
lively
lives
livelihood
livery
liveried
lizard
lizard's
lizards
load
loaded
loader
loaders
loading
loadings
loads
loaf
loafed
loafer
loan
loaned
loaning
loans
loath
loathly
loathe
loathed
loathing
loathsome
loaves
lobby
lobbied
lobbies
lobe
lobe's
lobes
lobster
lobster's
lobsters
local
locally
locals
locality
locality's
localities
localization
localize
localized
localizing
localizes
locate
located
locating
location
locations
locative
locates
locatives
locator
locator's
locators
loci
lock
locked
locker
lockers
locking
lockings
locks
lockout
lockout's
lockouts
lockup
lockup's
lockups
locomotion
locomotive
locomotive's
locomotives
locus
locust
locust's
locusts
lodge
lodged
lodger
lodging
lodgings
lodges
loft
loft's
lofts
lofty
loftiness
log
log's
logs
logarithm
logarithm's
logarithms
logged
logger
logger's
loggers
logging
logic
logic's
logics
logical
logically
logician
logician's
logicians
logistic
logistics
loin
loin's
loins
loiter
loitered
loiterer
loitering
loiters
lone
loner
loners
lonely
loneliness
loneliest
lonelier
lonesome
long
longed
longest
longer
longing
longings
longs
longitude
longitude's
longitudes
look
looked
looker
lookers
looking
looks
lookahead
lookout
lookup
lookup's
lookups
loom
loomed
looming
looms
loon
loop
looped
looping
loops
loophole
loophole's
loopholes
loose
looseness
loosed
loosest
looser
loosing
loosely
looses
loosen
loosened
loosening
loosens
loot
looted
looter
looting
loots
lord
lordly
lords
lordship
lore
lorry
lose
loser
losers
losing
loses
loss
loss's
losses
lossy
lossiest
lossier
lost
lot
lot's
lots
lottery
loud
loudness
loudest
louder
loudly
loudspeaker
loudspeaker's
loudspeakers
lounge
lounged
lounging
lounges
lousy
lovable
lovably
love
loved
lover
lovers
loving
loves
lovely
loveliness
loveliest
lovelier
lovelies
lovingly
low
lowness
lowest
lowly
lows
lower
lowered
lowering
lowers
lowland
lowlands
lowliest
loyal
loyally
loyalty
loyalty's
loyalties
lubricant
lubricant's
lubrication
luck
lucked
lucks
luckily
luckless
lucky
luckiest
luckier
ludicrous
ludicrousness
ludicrously
luggage
lukewarm
lull
lulled
lulls
lullaby
lumber
lumbered
lumbering
luminous
luminously
lump
lumped
lumping
lumps
lunar
lunatic
lunch
lunched
lunching
lunches
luncheon
luncheon's
luncheons
lung
lunged
lungs
lurch
lurched
lurching
lurches
lure
lured
luring
lures
lurk
lurked
lurking
lurks
luscious
lusciousness
lusciously
lust
luster
lusts
lustily
lustrous
lusty
lustiness
lute
lute's
lutes
luxuriant
luxuriantly
luxurious
luxuriously
luxury
luxury's
luxuries
lying
lymph
lynch
lynched
lyncher
lynches
lynx
lynx's
lynxes
lyre
lyric
lyrics
ma'am
mace
maced
maces
machine
machined
machine's
machining
machines
machinery
macro
macro's
macros
macroeconomics
macromolecule
macromolecule's
macromolecules
macroscopic
mad
madness
madly
madam
madden
maddening
madder
maddest
made
mademoiselle
madman
madras
magazine
magazine's
magazines
maggot
maggot's
maggots
magic
magical
magically
magician
magician's
magicians
magistrate
magistrate's
magistrates
magnesium
magnet
magnetic
magnetism
magnetism's
magnetisms
magnificence
magnificent
magnificently
magnify
magnified
magnifier
magnifying
magnification
magnifies
magnitude
magnitude's
magnitudes
mahogany
maid
maiden
maidens
maids
mail
mailed
mailer
mailing
mailings
mails
mailable
mailbox
mailbox's
mailboxes
maim
maimed
maiming
maims
main
mainly
mains
mainframe
mainframe's
mainframes
mainland
mainstay
maintain
maintained
maintainer
maintainers
maintaining
maintains
maintainability
maintainable
maintenance
maintenance's
maintenances
maize
majestic
majesty
majesty's
majesties
major
majored
majors
majority
majority's
majorities
makable
make
maker
makers
making
makings
makes
makeshift
makeup
makeups
malady
malady's
maladies
malaria
male
maleness
male's
males
malefactor
malefactor's
malefactors
malfunction
malfunctioned
malfunctioning
malfunctions
malice
malicious
maliciousness
maliciously
malignant
malignantly
mallet
mallet's
mallets
malnutrition
malt
malted
malts
mama
mamma
mamma's
mammas
mammal
mammal's
mammals
mammoth
man
man's
manly
mans
manage
managed
manager
managers
managing
manages
manageable
manageableness
management
management's
managements
manager
manager's
managers
managerial
mandate
mandated
mandating
mandates
mandatory
mandible
mane
mane's
manes
maneuver
maneuvered
maneuvering
maneuvers
manger
manger's
mangers
mangle
mangled
mangler
mangling
mangles
manhood
maniac
maniac's
maniacs
manicure
manicured
manicuring
manicures
manifest
manifested
manifesting
manifestly
manifests
manifestation
manifestation's
manifestations
manifold
manifold's
manifolds
manila
manipulability
manipulable
manipulatable
manipulate
manipulated
manipulating
manipulation
manipulations
manipulative
manipulates
manipulator
manipulator's
manipulators
manipulatory
mankind
manned
manner
mannered
mannerly
manners
manning
manometer
manometer's
manometers
manor
manor's
manors
manpower
mansion
mansion's
mansions
mantel
mantel's
mantels
mantissa
mantissa's
mantissas
mantle
mantle's
mantles
manual
manual's
manually
manuals
manufacture
manufactured
manufacturer
manufacturers
manufacturing
manufactures
manufacturer
manufacturer's
manufacturers
manure
manuscript
manuscript's
manuscripts
many
map
map's
maps
maple
maple's
maples
mappable
mapped
mapping
mapping's
mappings
mar
Mars
marble
marbling
marbles
march
marched
marcher
marching
marches
mare
mare's
mares
margin
margin's
margins
marginal
marginally
marigold
marijuana
marine
mariner
marines
maritime
mark
marked
marker
markers
marking
markings
marks
markable
markedly
market
marketed
marketing
marketings
markets
marketability
marketable
marketplace
marketplace's
marketplaces
marquis
marriage
marriage's
marriages
marrow
marry
married
marrying
marries
marsh
marsh's
marshes
marshal
marshaled
marshaling
marshals
mart
marten
marts
martial
martyr
martyr's
martyrs
martyrdom
marvel
marveled
marvels
marvelled
marvelling
marvelous
marvelousness
marvelously
Maryland
masculine
masculinely
masculinity
mash
mashed
mashing
mashes
mask
masked
masker
masking
maskings
masks
masochist
masochist's
masochists
mason
mason's
masons
masonry
masquerade
masquerader
masquerading
masquerades
mass
massed
massing
massive
masses
Massachusetts
massacre
massacred
massacres
massage
massaging
massages
mast
masted
masters
masts
master
mastered
master's
mastering
masterly
masterings
masters
masterful
masterfully
masterpiece
masterpiece's
masterpieces
mastery
masturbate
masturbated
masturbating
masturbation
masturbates
mat
mat's
mats
match
matched
matcher
matchers
matching
matchings
matches
matchable
matchless
mate
mated
mater
mate's
mating
matings
mates
material
materially
materials
materialize
materialized
materializing
materializes
maternal
maternally
math
mathematical
mathematically
mathematician
mathematician's
mathematicians
mathematics
matrices
matriculation
matrimony
matrix
matron
matronly
matted
matter
mattered
matters
mattress
mattress's
mattresses
maturation
mature
matured
maturing
maturely
matures
maturity
maturities
max
maxim
maxim's
maxims
maximal
maximally
maximize
maximized
maximizer
maximizers
maximizing
maximizes
maximum
maximums
may
maybe
mayhap
mayhem
mayonnaise
mayor
mayor's
mayors
mayoral
maze
maze's
mazes
me
mead
meadow
meadow's
meadows
meager
meagerness
meagerly
meal
meal's
meals
mean
meanness
meanest
meaner
meanly
means
meander
meandered
meandering
meanders
meaning
meaning's
meanings
meaningful
meaningfulness
meaningfully
meaningless
meaninglessness
meaninglessly
meant
meantime
meanwhile
measles
measurable
measurably
measure
measured
measurer
measuring
measures
measurement
measurement's
measurements
meat
meat's
meats
mechanic
mechanic's
mechanics
mechanical
mechanically
mechanism
mechanism's
mechanisms
mechanization
mechanization's
mechanizations
mechanize
mechanized
mechanizing
mechanizes
medal
medal's
medals
medallion
medallion's
medallions
meddle
meddled
meddler
meddling
meddles
media
median
median's
medians
mediate
mediated
mediating
mediation
mediations
mediates
medic
medic's
medics
medical
medically
medicinal
medicinally
medicine
medicine's
medicines
medieval
meditate
meditated
meditating
meditation
meditations
meditative
meditates
medium
medium's
mediums
Medusa
meek
meekness
meekest
meeker
meekly
meet
meeting
meetings
meets
melancholy
mellow
mellowness
mellowed
mellowing
mellows
melodious
melodiousness
melodiously
melodrama
melodrama's
melodramas
melody
melody's
melodies
melon
melon's
melons
melt
melted
melting
melts
meltingly
member
member's
members
membership
membership's
memberships
membrane
memo
memo's
memos
memoir
memoirs
memorable
memorableness
memoranda
memorandum
memorial
memorially
memorials
memorization
memorize
memorized
memorizer
memorizing
memorizes
memory
memory's
memories
memoryless
men
men's
mens
menace
menaced
menacing
menagerie
mend
mended
mender
mending
mends
menial
menials
mental
mentally
mentality
mentalities
mention
mentioned
mentioner
mentioners
mentioning
mentions
mentionable
mentor
mentor's
mentors
menu
menu's
menus
mercenary
mercenariness
mercenary's
mercenaries
merchandise
merchandiser
merchandising
merchant
merchant's
merchants
merciful
mercifully
merciless
mercilessly
mercury
mercy
mere
merest
merely
merge
merged
merger
mergers
merging
merges
meridian
merit
merited
meriting
merits
meritorious
meritoriousness
meritoriously
merrily
merriment
merry
merriest
mesh
mess
messed
messing
messes
message
message's
messages
messenger
messenger's
messengers
messiah
messiahs
messieurs
messily
messy
messiness
messiest
messier
met
mets
metacircular
metacircularity
metal
metal's
metals
metalanguage
metallic
metallization
metallizations
metallurgy
metamathematical
metamorphosis
metaphor
metaphor's
metaphors
metaphorical
metaphorically
metaphysical
metaphysically
metaphysics
metavariable
mete
meted
meter
meters
meting
metes
meteor
meteor's
meteors
meteoric
meteorology
metering
method
method's
methods
methodical
methodicalness
methodically
Methodist
Methodist's
Methodists
methodological
methodologically
methodologists
methodology
methodology's
methodologies
metric
metric's
metrics
metrical
metropolis
metropolitan
mew
mewed
mews
mica
mice
michigan
microbicidal
microbicide
microcode
microcoded
microcoding
microcodes
microcomputer
microcomputer's
microcomputers
microeconomics
microfilm
microfilm's
microfilms
microinstruction
microinstruction's
microinstructions
microphone
microphoning
microphones
microprocessing
microprocessor
microprocessor's
microprocessors
microprogram
microprogram's
microprograms
microprogrammed
microprogramming
microscope
microscope's
microscopes
microscopic
microsecond
microsecond's
microseconds
microstore
microword
microwords
mid
midday
middle
middling
middles
midnight
midnights
midpoint
midpoint's
midpoints
midst
midsts
midsummer
midway
midwest
midwinter
mien
might
mightily
mighty
mightiness
mightiest
mightier
migrate
migrated
migrating
migration
migrations
migrates
mild
mildness
mildest
milder
mildly
mildew
mile
mile's
miles
mileage
milestone
milestone's
milestones
militant
militantly
militarily
militarism
military
militia
milk
milked
milker
milkers
milking
milks
milkmaid
milkmaid's
milkmaids
milky
milkiness
mill
milled
miller
milling
mills
millet
millimeter
millimeters
million
millionth
millions
millionaire
millionaire's
millionaires
millipede
millipede's
millipedes
millisecond
milliseconds
millstone
millstone's
millstones
mimic
mimics
mimicked
mimicking
mince
minced
mincing
minces
mind
minded
minding
minds
mindful
mindfulness
mindfully
mindless
mindlessly
mine
mined
miner
miners
mining
minion
mines
mineral
mineral's
minerals
mingle
mingled
mingling
mingles
miniature
miniature's
miniatures
miniaturization
miniaturize
miniaturized
miniaturizing
miniaturizes
minicomputer
minicomputer's
minicomputers
minimal
minimally
minimization
minimization's
minimizations
minimize
minimized
minimizer
minimizers
minimizing
minimizes
minimum
minister
ministered
minister's
ministering
ministers
ministry
ministry's
ministries
mink
mink's
minks
Minnesota
Minnesota's
minnow
minnow's
minnows
minor
minor's
minors
minority
minority's
minorities
minstrel
minstrel's
minstrels
mint
minted
minter
minting
mints
minus
minute
minuteness
minuter
minutely
minutes
miracle
miracle's
miracles
miraculous
miraculously
mire
mired
mires
mirror
mirrored
mirroring
mirrors
mirth
misbehaving
miscalculation
miscalculation's
miscalculations
miscellaneous
miscellaneousness
miscellaneously
mischief
mischievous
mischievousness
mischievously
misconception
misconception's
misconceptions
misconstrue
misconstrued
misconstrues
miser
miserly
misers
miserable
miserableness
miserably
misery
misery's
miseries
misfit
misfit's
misfits
misfortune
misfortune's
misfortunes
misgiving
misgivings
mishap
mishap's
mishaps
misjudgment
mislead
misleading
misleads
misled
mismatch
mismatched
mismatching
mismatches
misnomer
misplace
misplaced
misplacing
misplaces
misrepresentation
misrepresentation's
misrepresentations
miss
missed
missing
missive
misses
missile
missile's
missiles
mission
missioner
missions
missionary
missionary's
missionaries
misspell
misspelled
misspelling
misspellings
misspells
mist
misted
mister
misters
misting
mists
mistakable
mistake
mistaking
mistakion
mistakes
mistaken
mistakenly
mistress
mistrust
mistrusted
misty
mistiness
mistype
mistyped
mistyping
mistypes
misunderstand
misunderstander
misunderstanders
misunderstanding
misunderstanding
misunderstanding's
misunderstandings
misunderstood
misuse
misused
misusing
misuses
mit
miter
mit's
mitigate
mitigated
mitigating
mitigation
mitigative
mitigates
mitten
mitten's
mittens
mix
mixed
mixer
mixers
mixing
mixes
mixture
mixture's
mixtures
mnemonic
mnemonic's
mnemonics
mnemonically
moan
moaned
moans
moat
moat's
moats
mob
mob's
mobs
moccasin
moccasin's
moccasins
mock
mocked
mocker
mocking
mocks
mockery
modal
modally
modality
modality's
modalities
mode
modest
modes
model
modeled
modeling
modelings
models
moderate
moderateness
moderated
moderating
moderation
moderately
moderates
modern
modernness
modernly
moderns
modernity
modernize
modernized
modernizer
modernizing
modestly
modesty
modifiability
modifiable
modify
modified
modifier
modifiers
modifying
modification
modifications
modifies
modular
modularly
modularity
modularization
modularize
modularized
modularizing
modularizes
modulate
modulated
modulating
modulation
modulations
modulates
modulator
modulator's
modulators
module
module's
modules
modulo
modulus
modus
moist
moistness
moisten
moistly
moisture
molasses
mold
molded
molder
molding
molds
mole
molest
moles
molecular
molecule
molecule's
molecules
molest
molested
molesting
molests
molten
moment
moment's
moments
momentarily
momentary
momentariness
momentous
momentousness
momentously
momentum
monarch
monarchs
monarchy
monarchy's
monarchies
monastery
monastery's
monasteries
monastic
Monday
Monday's
Mondays
monetary
money
moneyed
moneys
monitor
monitored
monitoring
monitors
monk
monk's
monks
monkey
monkeyed
monkeying
monkeys
monogram
monogram's
monograms
monograph
monograph's
monographes
monographs
monolithic
monopoly
monopoly's
monopolies
monotheism
monotone
monotonic
monotonically
monotonicity
monotonous
monotonousness
monotonously
monotony
monster
monster's
monsters
monstrous
monstrously
Montana
Montana's
month
monthly
months
monument
monument's
monuments
monumental
monumentally
mood
mood's
moods
moody
moodiness
moon
mooned
mooning
moons
moonlight
moonlighter
moonlighting
moonlit
moonshine
moor
moored
mooring
moorings
moors
moose
moot
mop
moped
mops
moral
morally
morals
morale
morality
moralities
morass
morbid
morbidness
morbidly
more
mores
moreover
morn
morning
mornings
morphism
morphisms
morphological
morphology
morrow
morsel
morsel's
morsels
mortal
mortally
mortals
mortality
mortar
mortared
mortaring
mortars
mortgage
mortgage's
mortgages
mortify
mortified
mortifying
mortification
mortifies
mosaic
mosaic's
mosaics
mosquito
mosquitoes
moss
moss's
mosses
mossy
most
mostly
motel
motel's
motels
moth
mothers
mother
mothered
motherer
motherers
mothering
motherly
mothers
mother's
motif
motif's
motifs
motion
motioned
motioning
motions
motionless
motionlessness
motionlessly
motivate
motivated
motivating
motivation
motivations
motivates
motive
motives
motley
motor
motoring
motors
motorcar
motorcar's
motorcars
motorcycle
motorcycle's
motorcycles
motorist
motorist's
motorists
motorize
motorized
motorizing
motorizes
motto
mottoes
mould
moulding
mound
mounded
mounds
mount
mounted
mounter
mounting
mountings
mounts
mountain
mountain's
mountains
mountaineer
mountaineering
mountaineers
mountainous
mountainously
mourn
mourned
mourner
mourners
mourning
mourns
mournful
mournfulness
mournfully
mouse
mouser
mouses
mouth
mouthe
mouthed
mouthing
mouthes
mouthful
mouths
movable
move
moved
mover
movers
moving
movings
moves
movement
movement's
movements
movie
movie's
movies
mow
mowed
mower
mows
Mr
Ms
much
muck
mucker
mucking
mud
muddle
muddled
muddler
muddlers
muddling
muddles
muddy
muddiness
muddied
muff
muff's
muffs
muffin
muffin's
muffins
muffle
muffled
muffler
muffling
muffles
mug
mug's
mugs
mulberry
mulberry's
mulberries
mule
mule's
mules
multicellular
multidimensional
multilevel
multinational
multiple
multiple's
multiples
multiplex
multiplexed
multiplexing
multiplexes
multiplexor
multiplexor's
multiplexors
multiplicand
multiplicand's
multiplicands
multiplicative
multiplicatives
multiplicity
multiply
multiplied
multiplier
multipliers
multiplying
multiplication
multiplications
multiplies
multiprocess
multiprocessing
multiprocessor
multiprocessor's
multiprocessors
multiprogram
multiprogrammed
multiprogramming
multistage
multitude
multitude's
multitudes
multivariate
mumble
mumbled
mumbler
mumblers
mumbling
mumblings
mumbles
mummy
mummy's
mummies
munch
munched
munching
mundane
mundanely
municipal
municipally
municipality
municipality's
municipalities
munition
munitions
mural
murder
murdered
murderer
murderers
murdering
murders
murderous
murderously
murky
murmur
murmured
murmurer
murmuring
murmurs
muscle
muscled
muscling
muscles
muscular
muse
mused
musing
musings
muses
museum
museum's
museums
mushroom
mushroomed
mushrooming
mushrooms
mushy
music
musical
musically
musicals
musician
musicianly
musicians
musk
musks
musket
musket's
muskets
muskrat
muskrat's
muskrats
muslin
mussel
mussel's
mussels
must
muster
musts
mustache
mustached
mustaches
mustard
musty
mustiness
mutability
mutable
mutableness
mutate
mutated
mutating
mutation
mutations
mutative
mutates
mute
muteness
muted
mutely
mutilate
mutilated
mutilating
mutilation
mutilates
mutiny
mutiny's
mutinies
mutter
muttered
mutterer
mutterers
muttering
mutters
mutton
mutual
mutually
muzzle
muzzle's
muzzles
my
myriad
myrtle
myself
mysterious
mysteriousness
mysteriously
mystery
mystery's
mysteries
mystic
mystic's
mystics
mystical
myth
mythical
mythology
mythology's
mythologies
nag
nag's
nags
nail
nailed
nailing
nails
naive
naiveness
naively
naivete
naked
nakedness
nakedly
name
named
namer
namers
naming
namely
names
nameable
nameless
namelessly
namesake
namesake's
namesakes
nanosecond
nanoseconds
nap
nap's
naps
napkin
napkin's
napkins
narcissus
narcotic
narcotics
narrative
narrative's
narratives
narrow
narrowness
narrowed
narrowest
narrower
narrowing
narrowly
narrows
nasal
nasally
nastily
nasty
nastiness
nastiest
nastier
nation
nation's
nations
national
nationally
nationals
nationalist
nationalist's
nationalists
nationality
nationality's
nationalities
nationalization
nationalize
nationalized
nationalizing
nationalizes
nationwide
native
natively
natives
nativity
natural
naturalness
naturally
naturals
naturalism
naturalist
naturalization
nature
natured
nature's
natures
naught
naughty
naughtiness
naughtier
naval
navally
navigable
navigate
navigated
navigating
navigation
navigates
navigator
navigator's
navigators
navy
navy's
navies
nay
Nazi
nazi's
nazis
near
nearness
neared
nearest
nearer
nearing
nearly
nears
nearby
neat
neatness
neatest
neater
neatly
nebula
necessarily
necessary
necessaries
necessitate
necessitated
necessitating
necessitation
necessitates
necessity
necessities
neck
necking
necks
necklace
necklace's
necklaces
necktie
necktie's
neckties
need
needed
needing
needs
needful
needle
needled
needler
needlers
needling
needles
needless
needlessness
needlessly
needlework
needn't
needy
negate
negated
negating
negation
negations
negative
negates
negatively
negatives
negator
negators
neglect
neglected
neglecting
neglects
negligence
negligible
negotiate
negotiated
negotiating
negotiation
negotiations
negotiates
Negro
Negroes
neigh
neighbor
neighboring
neighborly
neighbors
neighborhood
neighborhood's
neighborhoods
neither
neophyte
neophytes
nepal
nephew
nephew's
nephews
nerve
nerve's
nerves
nervous
nervousness
nervously
nest
nested
nester
nesting
nests
nestle
nestled
nestling
nestles
net
net's
nets
nether
netherlands
netted
netting
nettle
nettled
network
networked
network's
networking
networks
neural
neurological
neurologists
neuron
neuron's
neurons
neutral
neutrally
neutrality
neutralities
neutralize
neutralized
neutralizing
neutrino
neutrino's
neutrinos
never
nevertheless
new
newness
newest
newer
newly
news
newborn
newcomer
newcomer's
newcomers
newsman
newsmen
newspaper
newspaper's
newspapers
Newtonian
next
nibble
nibbled
nibbler
nibblers
nibbling
nibbles
nice
niceness
nicest
nicer
nicely
niche
nick
nicked
nicker
nicking
nicks
nickel
nickel's
nickels
nickname
nicknamed
nicknames
niece
niece's
nieces
nifty
nigh
night
nightly
nights
nightfall
nightgown
nightingale
nightingale's
nightingales
nightmare
nightmare's
nightmares
nil
nimble
nimbleness
nimbler
nimbly
nine
nines
nineteen
nineteenth
nineteens
ninety
ninetieth
nineties
ninth
nip
nips
nitrogen
no
nobility
noble
nobleness
noblest
nobler
nobles
nobleman
nobly
nobody
nocturnal
nocturnally
nod
nod's
nods
nodded
nodding
node
node's
nodes
noise
noises
noiseless
noiselessly
noisily
noisy
noisiness
noisier
nomenclature
nominal
nominally
nominate
nominated
nominating
nomination
nominative
non
nonblocking
nonconservative
noncyclic
nondecreasing
nondescript
nondescriptly
nondestructively
nondeterminacy
nondeterminate
nondeterminately
nondeterminism
nondeterministic
nondeterministically
none
nonempty
nonetheless
nonexistence
nonexistent
nonextensible
nonfunctional
noninteracting
noninterference
nonintuitive
nonlinear
nonlinearly
nonlinearity
nonlinearity's
nonlinearities
nonlocal
nonnegative
nonorthogonal
nonorthogonality
nonperishable
nonprocedural
nonprocedurally
nonprogrammable
nonprogrammer
nonsense
nonsensical
nonspecialist
nonspecialist's
nonspecialists
nontechnical
nonterminal
nonterminal's
nonterminals
nonterminating
nontermination
nontrivial
nonuniform
nonzero
nook
nook's
nooks
noon
noons
noonday
noontide
nor
north
norm
norm's
norms
normal
normally
normals
normalcy
normality
normalization
normalize
normalized
normalizing
normalizes
northeast
northeaster
northeastern
northern
northerner
northerners
northernly
northward
northwards
northwest
northwestern
nose
nosed
nosing
noses
nostril
nostril's
nostrils
not
notable
notables
notably
notarize
notarized
notarizing
notarizes
notation
notation's
notations
notational
notch
notched
notching
notches
note
noted
noting
notion
notions
notes
notebook
notebook's
notebooks
noteworthy
nothing
nothingness
nothings
notice
noticed
noticing
notices
noticeable
noticeably
notify
notified
notifier
notifiers
notifying
notification
notifications
notifies
notorious
notoriously
notwithstanding
noun
noun's
nouns
nourish
nourished
nourishing
nourishes
nourishment
novel
novel's
novels
novelist
novelist's
novelists
novelty
novelty's
novelties
November
novice
novice's
novices
now
nowadays
nowhere
nuances
nuclear
nucleotide
nucleotide's
nucleotides
nucleus
nuisance
nuisance's
nuisances
null
nulled
nulls
nullary
nullify
nullified
nullifiers
nullifying
nullifies
numb
numbness
numbed
numbers
numbing
numbly
numbs
number
numbered
numberer
numbering
numbers
numberless
numeral
numeral's
numerals
numerator
numerator's
numerators
numeric
numerics
numerical
numerically
numerous
nun
nun's
nuns
nuptial
nurse
nursed
nursing
nurses
nursery
nursery's
nurseries
nurture
nurtured
nurturing
nurtures
nut
nut's
nuts
nutrition
nymph
nymphs
o'clock
oak
oaken
oaks
oar
oar's
oars
oasis
oat
oaten
oats
oath
oaths
oatmeal
obedience
obediences
obedient
obediently
obey
obeyed
obeying
obeys
object
objected
objecter
object's
objecting
objective
objects
objection
objection's
objections
objectionable
objectively
objectives
objector
objector's
objectors
obligation
obligation's
obligations
obligatory
oblige
obliged
obliging
obliges
obligingly
oblique
obliqueness
obliquely
obliterate
obliterated
obliterating
obliteration
obliterates
oblivion
oblivious
obliviousness
obliviously
oblong
obscene
obscure
obscured
obscurer
obscuring
obscurely
obscures
obscurity
obscurities
observable
observance
observance's
observances
observant
observation
observation's
observations
observatory
observe
observed
observer
observers
observing
observes
obsession
obsession's
obsessions
obsolescence
obsolete
obsoleted
obsoleting
obsoletes
obstacle
obstacle's
obstacles
obstinacy
obstinate
obstinately
obstruct
obstructed
obstructing
obstructive
obstruction
obstruction's
obstructions
obtain
obtained
obtaining
obtains
obtainable
obtainably
obviate
obviated
obviating
obviation
obviations
obviates
obvious
obviousness
obviously
occasion
occasioned
occasioning
occasionings
occasions
occasional
occasionally
occlude
occluded
occludes
occlusion
occlusion's
occlusions
occupancy
occupancies
occupant
occupant's
occupants
occupation
occupation's
occupations
occupational
occupationally
occupy
occupied
occupier
occupying
occupies
occur
occurs
occurred
occurrence
occurrence's
occurrences
occurring
ocean
ocean's
oceans
octal
octave
octaves
October
octopus
odd
oddness
oddest
odder
oddly
odds
oddity
oddity's
oddities
ode
ode's
odes
odious
odiousness
odiously
odor
odor's
odors
odorous
odorousness
odorously
oedipus
of
off
offing
offend
offended
offender
offenders
offending
offends
offense
offensive
offenses
offensively
offensiveness
offer
offered
offerer
offerers
offering
offerings
offers
office
officer
officers
offices
officer's
official
officially
officials
officio
officious
officiousness
officiously
offset
offset's
offsets
offspring
oft
often
oftentimes
oh
Ohio
ohio's
oil
oiled
oiler
oilers
oiling
oils
oilcloth
oily
oiliest
oilier
ointment
ok
okay
old
oldness
oldest
older
olden
olive
olive's
olives
omen
omen's
omens
ominous
ominousness
ominously
omission
omission's
omissions
omit
omits
omitted
omitting
omnipresent
omniscient
omnisciently
omnivore
on
only
onanism
onboard
once
one
oneness
one's
onion
onions
ones
onerous
oneself
ongoing
online
onset
onset's
onsets
onto
onward
onwards
ooze
oozed
opacity
opal
opal's
opals
opaque
opaqueness
opaquely
opcode
open
openness
opened
opener
openers
openly
opens
opening
opening's
openings
opera
opera's
operas
operable
operand
operand's
operands
operandi
operate
operated
operating
operation
operations
operative
operates
operational
operationally
operatives
operator
operator's
operators
opinion
opinion's
opinions
opium
opponent
opponent's
opponents
opportune
opportunely
opportunism
opportunistic
opportunity
opportunity's
opportunities
oppose
opposed
opposing
opposes
opposite
oppositeness
opposition
oppositely
opposites
oppress
oppressed
oppressing
oppressive
oppresses
oppression
oppressor
oppressor's
oppressors
opt
opted
opting
opts
optic
optics
optical
optically
optimal
optimally
optimality
optimism
optimistic
optimistically
optimization
optimization's
optimizations
optimize
optimized
optimizer
optimizers
optimizing
optimizes
optimum
option
option's
options
optional
optionally
or
or's
orly
oracle
oracle's
oracles
oral
orally
orange
orange's
oranges
oration
oration's
orations
orator
orator's
orators
oratory
oratory's
oratories
orb
orbit
orbited
orbiter
orbiters
orbiting
orbits
orbital
orbitally
orchard
orchard's
orchards
orchestra
orchestra's
orchestras
orchid
orchid's
orchids
ordain
ordained
ordaining
ordains
ordeal
order
ordered
ordering
orderly
orderings
orders
orderlies
ordinal
ordinance
ordinance's
ordinances
ordinarily
ordinary
ordinariness
ordinate
ordination
ordinates
ore
ore's
ores
organ
organ's
organs
organic
organism
organism's
organisms
organist
organist's
organists
organizable
organization
organization's
organizations
organizational
organizationally
organize
organized
organizer
organizers
organizing
organizes
orgy
orgy's
orgies
orient
oriented
orienting
orients
orientation
orientation's
orientations
orifice
orifice's
orifices
origin
origin's
origins
original
originally
originals
originality
originate
originated
originating
origination
originates
originator
originator's
originators
ornament
ornamented
ornamenting
ornaments
ornamental
ornamentally
ornamentation
orphan
orphaned
orphans
orthodox
orthogonal
orthogonally
orthogonality
oscillate
oscillated
oscillating
oscillation
oscillations
oscillates
oscillation
oscillation's
oscillations
oscillator
oscillator's
oscillators
oscillatory
oscilloscope
oscilloscope's
oscilloscopes
ostrich
ostrich's
ostriches
other
others
otherwise
otter
otter's
otters
ought
ounce
ounces
our
ours
ourself
ourselves
out
outer
outing
outs
outbreak
outbreak's
outbreaks
outburst
outburst's
outbursts
outcast
outcast's
outcasts
outcome
outcome's
outcomes
outcry
outcries
outdoor
outdoors
outermost
outfit
outfit's
outfits
outgoing
outgrew
outgrow
outgrowing
outgrowth
outgrows
outgrown
outlast
outlasts
outlaw
outlawed
outlawing
outlaws
outlay
outlay's
outlays
outlet
outlet's
outlets
outline
outlined
outlining
outlines
outlive
outlived
outliving
outlives
outlook
outperform
outperformed
outperforming
outperforms
outpost
outpost's
outposts
output
output's
outputs
outputting
outrage
outraged
outrages
outrageous
outrageously
outright
outrun
outruns
outset
outside
outsider
outsider
outsider's
outsiders
outskirts
outstanding
outstandingly
outstretched
outstrip
outstrips
outstripped
outstripping
outvote
outvoted
outvoting
outvotes
outward
outwardly
outweigh
outweighed
outweighing
outweighs
outwit
outwits
outwitted
outwitting
oval
oval's
ovals
ovary
ovary's
ovaries
oven
oven's
ovens
over
overly
overall
overall's
overalls
overboard
overcame
overcoat
overcoat's
overcoats
overcome
overcoming
overcomes
overcrowd
overcrowded
overcrowding
overcrowds
overdone
overdraft
overdraft's
overdrafts
overdue
overemphasis
overemphasized
overestimate
overestimated
overestimating
overestimation
overestimates
overflow
overflowed
overflowing
overflows
overhang
overhanging
overhangs
overhaul
overhauling
overhead
overheads
overhear
overhearing
overhears
overheard
overjoy
overjoyed
overland
overlap
overlap's
overlaps
overlapped
overlapping
overlay
overlayed
overlaying
overlays
overload
overloaded
overloading
overloads
overlook
overlooked
overlooking
overlooks
overnight
overnighter
overnighters
overpower
overpowered
overpowering
overpowers
overprint
overprinted
overprinting
overprints
overproduction
overridden
override
overriding
overrides
overrode
overrule
overruled
overrules
overrun
overruns
overseas
oversee
overseer
overseers
oversees
overseeing
overshadow
overshadowed
overshadowing
overshadows
overshoot
overshot
oversight
oversight's
oversights
oversimplify
oversimplified
oversimplifying
oversimplifies
overstate
overstated
overstating
overstates
overstatement
overstatement's
overstatements
overstocks
overt
overtly
overtake
overtaker
overtakers
overtaking
overtakes
overtaken
overthrew
overthrow
overthrown
overtime
overtone
overtone's
overtones
overtook
overture
overture's
overtures
overturn
overturned
overturning
overturns
overuse
overview
overview's
overviews
overwhelm
overwhelmed
overwhelming
overwhelms
overwhelmingly
overwork
overworked
overworking
overworks
overwrite
overwriting
overwrites
overwritten
overzealous
owe
owed
owing
owes
owl
owl's
owls
own
owned
owner
owners
owning
owns
ownership
ownerships
ox
oxen
oxide
oxide's
oxides
oxidize
oxidized
oxygen
oyster
oyster's
oysters
pa
path
pace
paced
pacer
pacers
pacing
paces
pacific
pacify
pacifier
pacification
pacifies
pack
packed
packer
packers
packing
packs
package
packaged
packager
packagers
packaging
packagings
packages
packet
packet's
packets
pact
pact's
pacts
pad
pad's
pads
padded
padding
paddle
paddy
pagan
pagan's
pagans
page
paged
pager
pagers
paging
pages
page's
pageant
pageant's
pageants
paginate
paginated
paginating
pagination
paginates
paid
pail
pail's
pails
pain
pained
pains
painful
painfully
painstaking
painstakingly
paint
painted
painter
painters
painting
paintings
paints
pair
paired
pairing
pairings
pairs
pairwise
pajama
pajamas
pal
pal's
pals
palace
palace's
palaces
palate
palate's
palates
pale
paleness
paled
palest
paler
paling
palely
pales
palfrey
pall
palliate
palliative
pallid
palm
palmed
palmer
palming
palms
pamphlet
pamphlet's
pamphlets
pan
pan's
pans
panacea
panacea's
panaceas
pancake
pancake's
pancakes
pandemonium
pane
pane's
panes
panel
paneled
paneling
panels
panelist
panelist's
panelists
pang
pang's
pangs
panic
panic's
panics
panned
panning
pansy
pansy's
pansies
pant
panted
panting
pants
panther
panther's
panthers
pantry
pantry's
pantries
panty
panties
papa
papal
paper
papered
paperer
paperers
papering
paperings
papers
paper's
paperback
paperback's
paperbacks
paperwork
paprika
par
pars
parachute
parachute's
parachutes
parade
paraded
parading
parades
paradigm
paradigm's
paradigms
paradise
paradox
paradox's
paradoxes
paradoxical
paradoxically
paraffin
paragon
paragon's
paragons
paragraph
paragraphing
paragraphs
parallel
paralleled
paralleling
parallels
parallelism
parallelize
parallelized
parallelizing
parallelizes
parallelled
parallelling
parallelogram
parallelogram's
parallelograms
paralysis
paralyze
paralyzed
paralyzing
paralyzes
parameter
parameter's
parameters
parameterizable
parameterization
parameterization's
parameterizations
parameterize
parameterized
parameterizing
parameterizes
parameterless
parametric
paramilitary
paramount
paranoia
paranoid
parapet
parapet's
parapets
paraphrase
paraphrased
paraphrasing
paraphrases
parasite
parasite's
parasites
parasitic
parasitics
parcel
parceled
parceling
parcels
parch
parched
parchment
pardon
pardoned
pardoner
pardoners
pardoning
pardons
pardonable
pardonably
pare
paring
parings
pares
parent
parent's
parents
parentage
parental
parentheses
parenthesis
parenthesized
parenthetical
parenthetically
parenthood
parish
parish's
parishes
parity
park
parked
parker
parkers
parking
parks
parliament
parliament's
parliaments
parliamentary
parlor
parlor's
parlors
parole
paroled
paroling
paroles
parrot
parroting
parrots
parry
parried
parse
parsed
parser
parsers
parsing
parsings
parses
parsimony
parsley
parson
parson's
parsons
part
parted
parter
parters
parting
partly
partings
parts
partake
partaker
partaking
partakes
partial
partially
partiality
participant
participant's
participants
participate
participated
participating
participation
participates
particle
particle's
particles
particular
particularly
particulars
partisan
partisan's
partisans
partition
partitioned
partitioning
partitions
partner
partnered
partners
partnership
partridge
partridge's
partridges
party
party's
parties
Pascal
pass
passage
passage's
passages
passageway
passe
passed
passer
passers
passing
passion
passions
passes
passenger
passenger's
passengers
passionate
passionately
passive
passiveness
passively
passivity
passport
passport's
passports
password
password's
passwords
past
pastness
past's
pasts
paste
pasted
pasting
pastes
pastime
pastime's
pastimes
pastor
pastor's
pastors
pastoral
pastry
pasture
pasture's
pastures
pat
paten
pats
patch
patched
patching
patches
patchwork
patent
patented
patenter
patenters
patenting
patently
patents
patentable
paternal
paternally
pathetic
pathological
pathology
pathos
paths
pathway
pathway's
pathways
patience
patient
patiently
patients
patriarch
patriarchs
patrician
patrician's
patricians
patriot
patriot's
patriots
patriotic
patriotism
patrol
patrol's
patrols
patron
patron's
patrons
patronage
patronize
patronized
patronizing
patronizes
patter
pattered
pattering
patterings
patters
pattern
patterned
patterning
patterns
patty
patty's
patties
paucity
pause
paused
pausing
pauses
pave
paved
paving
paves
pavement
pavement's
pavements
pavilion
pavilion's
pavilions
paw
pawing
paws
pawn
pawn's
pawns
pay
payed
paying
pays
payable
paycheck
paycheck's
paychecks
payer
payer's
payers
payment
payment's
payments
payoff
payoff's
payoffs
payroll
pea
pea's
peas
peace
peaceable
peaceful
peacefulness
peacefully
peach
peach's
peaches
peacock
peacock's
peacocks
peak
peaked
peaks
peal
pealed
pealing
peals
peanut
peanut's
peanuts
pear
pearly
pears
pearl
pearl's
pearls
peasant
peasant's
peasants
peasantry
peat
pebble
pebble's
pebbles
peck
pecked
pecking
pecks
peculiar
peculiarly
peculiarity
peculiarity's
peculiarities
pedagogic
pedagogical
pedantic
peddler
peddler's
peddlers
pedestal
pedestrian
pedestrian's
pedestrians
pediatric
pediatrics
peek
peeked
peeking
peeks
peel
peeled
peeling
peels
peep
peeped
peeper
peeping
peeps
peer
peered
peering
peers
peerless
peg
peg's
pegs
pelt
pelting
pelts
pen
penalize
penalized
penalizing
penalizes
penalty
penalty's
penalties
penance
pence
pencil
penciled
pencils
pend
pended
pending
pends
pendulum
pendulum's
pendulums
penetrate
penetrated
penetrating
penetration
penetrations
penetrative
penetrates
penetratingly
penetrator
penetrator's
penetrators
penguin
penguin's
penguins
peninsula
peninsula's
peninsulas
penitent
penitentiary
penned
penniless
penning
pennsylvania
penny
penny's
pennies
pens
pensive
pension
pensioner
pensions
pent
pentagon
pentagon's
pentagons
people
peopled
people's
peoples
pep
pepper
peppered
peppering
peppers
per
perceivable
perceivably
perceive
perceived
perceiver
perceivers
perceiving
perceives
percent
percents
percentage
percentages
percentile
percentiles
perceptible
perceptibly
perception
perceptions
perceptive
perceptively
perceptual
perceptually
perch
perched
perching
perches
perchance
percutaneous
peremptory
perennial
perennially
perfect
perfectness
perfected
perfecting
perfectly
perfects
perfection
perfectionist
perfectionist's
perfectionists
perforce
perform
performed
performer
performers
performing
performs
performance
performance's
performances
perfume
perfumed
perfuming
perfumes
perhaps
peril
peril's
perils
perilous
perilously
period
period's
periods
periodic
periodical
periodically
periodicals
peripheral
peripherally
peripherals
periphery
periphery's
peripheries
perish
perished
perisher
perishers
perishing
perishes
perishable
perishable's
perishables
permanence
permanent
permanently
permeate
permeated
permeating
permeation
permeates
permissibility
permissible
permissibly
permission
permissions
permissive
permissively
permit
permit's
permits
permitted
permitting
permutation
permutation's
permutations
permute
permuted
permuting
permutes
perpendicular
perpendicularly
perpendiculars
perpetrate
perpetrated
perpetrating
perpetration
perpetrations
perpetrates
perpetrator
perpetrator's
perpetrators
perpetual
perpetually
perpetuate
perpetuated
perpetuating
perpetuation
perpetuates
perplex
perplexed
perplexing
perplexity
persecute
persecuted
persecuting
persecution
persecutes
persecutor
persecutor's
persecutors
perseverance
persevere
persevered
persevering
perseveres
persist
persisted
persisting
persists
persistence
persistent
persistently
person
person's
persons
personage
personage's
personages
personal
personally
personality
personality's
personalities
personalization
personalize
personalized
personalizing
personalizes
personify
personified
personifying
personification
personifies
personnel
perspective
perspective's
perspectives
perspicuous
perspicuously
perspiration
persuadable
persuade
persuaded
persuader
persuaders
persuading
persuades
persuasion
persuasion's
persuasions
persuasive
persuasiveness
persuasively
pertain
pertained
pertaining
pertains
pertinent
perturb
perturbed
perturbation
perturbation's
perturbations
perusal
peruse
perused
peruser
perusers
perusing
peruses
pervade
pervaded
pervading
pervades
pervasive
pervasively
pervert
perverted
perverts
pessimistic
pest
pester
pests
pestilence
pet
peter
peters
pets
petal
petal's
petals
petition
petitioned
petitioner
petitioning
petitions
petroleum
petted
petter
petter's
petters
petticoat
petticoat's
petticoats
petting
petty
pettiness
pew
pew's
pews
pewter
phantom
phantom's
phantoms
phase
phased
phaser
phasers
phasing
phases
pheasant
pheasant's
pheasants
phenomena
phenomenal
phenomenally
phenomenological
phenomenologically
phenomenology
phenomenologies
phenomenon
philosopher
philosopher's
philosophers
philosophic
philosophical
philosophically
philosophize
philosophized
philosophizer
philosophizers
philosophizing
philosophizes
philosophy
philosophy's
philosophies
phone
phoned
phoning
phones
phoneme
phoneme's
phonemes
phonemic
phonetic
phonetics
phonograph
phonographs
phosphate
phosphate's
phosphates
phosphoric
photo
photo's
photos
photocopy
photocopied
photocopying
photocopies
photograph
photographed
photographer
photographers
photographing
photographic
photographs
photography
phrase
phrased
phrasing
phrasings
phrases
phyla
phylum
physic
physics
physical
physicalness
physically
physicals
physician
physician's
physicians
physicist
physicist's
physicists
physiological
physiologically
physiology
physique
pi
piano
piano's
pianos
piazza
piazza's
piazzas
picayune
pick
picked
picker
pickers
picking
pickings
picks
picket
picketed
picketer
picketers
picketing
pickets
pickle
pickled
pickling
pickles
pickup
pickup's
pickups
picnic
picnic's
picnics
pictorial
pictorially
picture
pictured
picturing
pictures
picturesque
picturesqueness
pie
pier
piers
pies
piece
pieced
piecing
pieces
piecemeal
piecewise
pierce
pierced
piercing
pierces
piety
pig
pig's
pigs
pigeon
pigeon's
pigeons
pigment
pigmented
pigments
pike
piker
pikes
pile
piled
pilers
piling
pilings
piles
pilferage
pilgrim
pilgrim's
pilgrims
pilgrimage
pilgrimage's
pilgrimages
pill
pill's
pills
pillage
pillaged
pillar
pillared
pillars
pillow
pillow's
pillows
pilot
piloting
pilots
pin
pin's
pins
pinch
pinched
pinching
pinches
pine
pined
pining
pinion
pines
pineapple
pineapple's
pineapples
ping
pink
pinkness
pinkest
pinker
pinkly
pinks
pinnacle
pinnacle's
pinnacles
pinned
pinning
pinnings
pinpoint
pinpointing
pinpoints
pint
pint's
pints
pioneer
pioneered
pioneering
pioneers
pious
piously
pipe
piped
piper
pipers
piping
pipes
pipeline
pipelined
pipelining
pipelines
pique
pirate
pirate's
pirates
pistil
pistil's
pistils
pistol
pistol's
pistols
piston
piston's
pistons
pit
pit's
pits
pitch
pitched
pitcher
pitchers
pitching
pitches
piteous
piteously
pitfall
pitfall's
pitfalls
pith
pithed
pithing
pithes
pithy
pithiness
pithiest
pithier
pitiable
pitiful
pitifully
pitiless
pitilessly
pitted
pity
pitied
pitier
pitiers
pitying
pities
pityingly
pivot
pivoting
pivots
pivotal
placard
placard's
placards
place
placed
placer
placing
places
placement
placement's
placements
placid
placidly
plague
plagued
plaguing
plagues
plaid
plaid's
plaids
plain
plainness
plainest
plainer
plainly
plains
plaintiff
plaintiff's
plaintiffs
plaintive
plaintiveness
plaintively
plait
plait's
plaits
plan
plan's
plans
planar
planarity
plane
planed
planer
planers
planing
planes
plane's
planet
planet's
planets
planetary
plank
planking
planks
planned
planner
planner's
planners
planning
plant
planted
planter
planters
planting
plantings
plants
plantation
plantation's
plantations
plasma
plaster
plastered
plasterer
plastering
plasters
plastic
plastics
plasticity
plate
plated
plating
plates
plateau
plateau's
plateaus
platelet
platelet's
platelets
platen
platen's
platens
platform
platform's
platforms
platinum
platter
platter's
platters
plausibility
plausible
play
played
playing
plays
playable
player
player's
players
playful
playfulness
playfully
playground
playground's
playgrounds
playmate
playmate's
playmates
plaything
plaything's
playthings
playwright
playwright's
playwrights
plea
plea's
pleas
plead
pleaded
pleader
pleading
pleads
pleasant
pleasantness
pleasantly
please
pleased
pleasing
pleases
pleasingly
pleasure
pleasures
plebeian
plebiscite
plebiscite's
plebiscites
pledge
pledged
pledges
plenary
plenteous
plentiful
plentifully
plenty
pleurisy
plight
plod
plot
plot's
plots
plotted
plotter
plotter's
plotters
plotting
plough
ploughman
plow
plowed
plower
plowing
plows
plowman
ploy
ploy's
ploys
pluck
plucked
plucking
plucky
plug
plug's
plugs
plugged
plugging
plum
plum's
plums
plumage
plumb
plumbed
plumb's
plumbing
plumbs
plume
plumed
plumes
plummeting
plump
plumpness
plumped
plunder
plundered
plunderer
plunderers
plundering
plunders
plunge
plunged
plunger
plungers
plunging
plunges
plural
plurals
plurality
plus
plush
ply
plied
pliers
plies
pneumonia
poach
poacher
poaches
pocket
pocketed
pocketing
pockets
pocketbook
pocketbook's
pocketbooks
pod
pod's
pods
poem
poem's
poems
poet
poet's
poets
poetic
poetics
poetical
poetically
poetry
poetry's
poetries
point
pointed
pointer
pointers
pointing
points
pointedly
pointless
pointy
poise
poised
poises
poison
poisoned
poisoner
poisoning
poisons
poisonous
poisonousness
poke
poked
poker
poking
pokes
Poland
polar
polarity
polarity's
polarities
pole
poled
poling
poles
polemic
polemics
police
policed
police's
policing
polices
policeman
policemen
policy
policy's
policies
polish
polished
polisher
polishers
polishing
polishes
polite
politeness
politest
politer
politely
politic
politics
political
politically
politician
politician's
politicians
poll
polled
polling
pollen
polls
pollute
polluted
polluting
pollution
pollutes
polo
polymer
polymer's
polymers
polynomial
polynomial's
polynomials
pomp
pompous
pompousness
pompously
pond
ponder
ponds
ponder
pondered
pondering
ponders
ponderous
pony
pony's
ponies
pool
pooled
pooling
pools
poor
poorness
poorest
poorer
poorly
pop
pop's
pops
poplar
popped
popping
poppy
poppy's
poppies
populace
popular
popularly
popularity
popularization
popularize
popularized
popularizing
popularizes
populate
populated
populating
population
populations
populates
populous
populousness
porcelain
porch
porch's
porches
porcupine
porcupine's
porcupines
pore
pored
poring
pores
pork
porker
pornographic
porridge
port
porter
porters
portly
ports
portability
portable
portal
portal's
portals
portend
portended
portending
portends
portion
portion's
portions
portrait
portrait's
portraits
portray
portrayed
portraying
portrays
pose
posed
poser
posers
posing
poses
posit
posited
positing
posits
position
positioned
positioning
positions
positional
positive
positiveness
positively
positives
possess
possessed
possessing
possessive
possesses
possession
possession's
possessions
possessional
possessive
possessiveness
possessively
possessor
possessor's
possessors
possibility
possibility's
possibilities
possible
possibly
possum
possum's
possums
post
posted
poster
posters
posting
posts
postage
postal
postcondition
posterior
posterity
postman
postmaster
postmaster's
postmasters
postoffice
postoffice's
postoffices
postpone
postponed
postponing
postscript
postscript's
postscripts
postulate
postulated
postulating
postulation
postulations
postulates
posture
posture's
postures
pot
pot's
pots
potash
potassium
potato
potatoes
potent
potentate
potentate's
potentates
potential
potentially
potentials
potentiality
potentialities
potentiating
potentiometer
potentiometer's
potentiometers
potted
potter
potter's
potters
pottery
potting
pouch
pouch's
pouches
poultry
pounce
pounced
pouncing
pounces
pound
pounded
pounder
pounders
pounding
pounds
pour
poured
pourer
pourers
pouring
pours
pout
pouted
pouting
pouts
poverty
powder
powdered
powdering
powders
power
powered
powering
powers
powerful
powerfulness
powerfully
powerless
powerlessness
powerlessly
powerset
powerset's
powersets
pox
practicable
practicably
practical
practically
practicality
practice
practiced
practicing
practices
practitioner
practitioner's
practitioners
pragmatic
pragmatics
pragmatically
prairie
praise
praised
praiser
praisers
praising
praises
praisingly
prance
pranced
prancer
prancing
prank
prank's
pranks
prate
pray
prayed
praying
prayer
prayer's
prayers
preach
preached
preacher
preachers
preaching
preaches
preassign
preassigned
preassigning
preassigns
precarious
precariousness
precariously
precaution
precaution's
precautions
precede
preceded
preceding
precedes
precedence
precedence's
precedences
precedent
precedented
precedents
precept
precept's
precepts
precinct
precinct's
precincts
precious
preciousness
preciously
precipice
precipitate
precipitateness
precipitated
precipitating
precipitation
precipitately
precipitates
precipitous
precipitously
precise
preciseness
precision
precisions
precisely
preclude
precluded
precluding
precludes
precocious
precociously
preconceive
preconceived
preconception
preconception's
preconceptions
precondition
preconditioned
preconditions
precursor
precursor's
precursors
predate
predated
predating
predates
predecessor
predecessor's
predecessors
predefine
predefined
predefining
predefines
predefinition
predefinition's
predefinitions
predetermine
predetermined
predetermining
predetermines
predicament
predicate
predicated
predicating
predication
predications
predicates
predict
predicted
predicting
predictive
predicts
predictability
predictable
predictably
prediction
prediction's
predictions
predominant
predominantly
predominate
predominated
predominating
predomination
predominately
predominates
preempt
preempted
preempting
preemptive
preempts
preemption
preface
prefaced
prefacing
prefaces
prefer
prefers
preferable
preferably
preference
preference's
preferences
preferential
preferentially
preferred
preferring
prefix
prefixed
prefixes
pregnant
prehistoric
preinitialize
preinitialized
preinitializing
preinitializes
prejudge
prejudged
prejudice
prejudiced
prejudices
prelate
preliminary
preliminaries
prelude
prelude's
preludes
premature
prematurely
prematurity
premeditated
premier
premier's
premiers
premise
premise's
premises
premium
premium's
premiums
preoccupation
preoccupy
preoccupied
preoccupies
preparation
preparation's
preparations
preparative
preparative's
preparatives
preparatory
prepare
prepared
preparing
prepares
preposition
preposition's
prepositions
prepositional
preposterous
preposterously
preproduction
preprogrammed
prerequisite
prerequisite's
prerequisites
prerogative
prerogative's
prerogatives
prescribe
prescribed
prescribes
prescription
prescription's
prescriptions
prescriptive
preselect
preselected
preselecting
preselects
presence
presence's
presences
present
presentness
presented
presenter
presenting
presently
presents
presentation
presentation's
presentations
preservation
preservations
preserve
preserved
preserver
preservers
preserving
preserves
preset
preside
presided
presiding
presides
presidency
president
president's
presidents
presidential
press
pressed
presser
pressing
pressings
presses
pressure
pressured
pressuring
pressures
pressurize
pressurized
prestige
presumably
presume
presumed
presuming
presumes
presumption
presumption's
presumptions
presumptuous
presumptuousness
presuppose
presupposed
presupposing
presupposes
pretend
pretended
pretender
pretenders
pretending
pretends
pretense
pretension
pretensions
pretenses
pretentious
pretentiousness
pretentiously
pretext
pretext's
pretexts
prettily
pretty
prettiness
prettiest
prettier
prevail
prevailed
prevailing
prevails
prevailingly
prevalence
prevalent
prevalently
prevent
prevented
preventing
preventive
prevents
preventable
preventably
prevention
preventives
preview
previewed
previewing
previews
previous
previously
prey
preyed
preying
preys
price
priced
pricer
pricers
pricing
prices
priceless
prick
pricked
pricking
prickly
pricks
pride
prided
priding
prides
primacy
primarily
primary
primary's
primaries
prime
primeness
primed
primer
primers
priming
primes
primeval
primitive
primitiveness
primitively
primitives
primrose
prince
princely
princes
princess
princess's
princesses
principal
principally
principals
principality
principality's
principalities
principle
principled
principles
print
printed
printer
printers
printing
prints
printable
printably
printout
prior
priori
priority
priority's
priorities
priory
prism
prism's
prisms
prison
prisoner
prisoners
prisons
prisoner's
privacy
privacies
private
privation
privations
privately
privates
privilege
privileged
privileges
privy
privy's
privies
prize
prized
prizer
prizers
prizing
prizes
pro
pro's
pros
probabilistic
probabilistically
probability
probabilities
probable
probably
probate
probated
probating
probation
probative
probates
probe
probed
probing
probings
probes
problem
problem's
problems
problematic
problematical
problematically
procedural
procedurally
procedure
procedure's
procedures
proceed
proceeded
proceeding
proceedings
proceeds
process
processed
process's
processing
processes
procession
processor
processor's
processors
proclaim
proclaimed
proclaimer
proclaimers
proclaiming
proclaims
proclamation
proclamation's
proclamations
proclivity
proclivity's
proclivities
procrastinate
procrastinated
procrastinating
procrastination
procrastinates
procure
procured
procurer
procurers
procuring
procures
procurement
procurement's
procurements
prodigal
prodigally
prodigious
produce
produced
producer
producers
producing
produces
producible
product
product's
productive
products
production
production's
productions
productively
productivity
profane
profanely
profess
professed
professing
professes
profession
profession's
professions
professional
professionally
professionals
professionalism
professor
professor's
professors
proffer
proffered
proffers
proficiency
proficient
proficiently
profile
profiled
profiling
profiles
profit
profited
profiting
profits
profitability
profitable
profitably
profiteer
profiteer's
profiteers
profitted
profitter
profitter's
profitters
profound
profoundest
profoundly
prog
progeny
program
program's
programs
programmability
programmable
programmed
programmer
programmer's
programmers
programming
progress
progressed
progressing
progressive
progresses
progression
progression's
progressions
progressive
progressively
prohibit
prohibited
prohibiting
prohibitive
prohibits
prohibition
prohibition's
prohibitions
prohibitively
project
projected
projecting
projective
projects
projection
projection's
projections
projectively
projector
projector's
projectors
prolegomena
proletariat
proliferate
proliferated
proliferating
proliferation
proliferates
prolific
prologue
prolong
prolonged
prolonging
prolongs
promenade
promenade's
promenades
prominence
prominent
prominently
promise
promised
promising
promises
promontory
promote
promoted
promoter
promoters
promoting
promotion
promotions
promotes
promotional
prompt
promptness
prompted
promptest
prompter
promptly
prompts
prompting
promptings
promulgate
promulgated
promulgating
promulgation
promulgates
prone
proneness
prong
pronged
prongs
pronoun
pronoun's
pronouns
pronounce
pronounced
pronouncing
pronounces
pronounceable
pronouncement
pronouncement's
pronouncements
pronunciation
pronunciation's
pronunciations
proof
proof's
proofs
prop
proper
props
propaganda
propagate
propagated
propagating
propagation
propagations
propagates
propel
propels
propelled
propeller
propeller's
propellers
propensity
properly
properness
property
propertied
properties
prophecy
prophecy's
prophecies
prophesy
prophesied
prophesier
prophesies
prophet
prophet's
prophets
prophetic
propitious
proponent
proponent's
proponents
proportion
proportioned
proportioning
proportions
proportional
proportionally
proportionately
proportionment
proposal
proposal's
proposals
propose
proposed
proposer
proposing
proposes
proposition
propositioned
propositioning
propositions
propositional
propositionally
propound
propounded
propounding
propounds
proprietary
proprietor
proprietor's
proprietors
propriety
propulsion
propulsion's
propulsions
prose
prosecute
prosecuted
prosecuting
prosecution
prosecutions
prosecutes
proselytize
proselytized
proselytizing
proselytizes
prosodic
prosodics
prospect
prospected
prospecting
prospective
prospects
prospection
prospection's
prospections
prospectively
prospectives
prospector
prospector's
prospectors
prospectus
prosper
prospered
prospering
prospers
prosperity
prosperous
prostitution
prostrate
prostration
protect
protected
protecting
protective
protects
protection
protection's
protections
protectively
protectiveness
protector
protector's
protectors
protectorate
protege
protege's
proteges
protein
protein's
proteins
protest
protested
protesting
protests
protestation
protestations
protestingly
protestor
protestor's
protestors
protocol
protocol's
protocols
proton
proton's
protons
protoplasm
prototype
prototyped
prototyping
prototypes
prototypical
prototypically
protrude
protruded
protruding
protrudes
protrusion
protrusion's
protrusions
proud
proudest
prouder
proudly
provability
provable
provably
prove
proved
prover
provers
proving
proves
proven
proverb
proverb's
proverbs
provide
provided
provider
providers
providing
provides
providence
province
province's
provinces
provincial
provision
provisioned
provisioning
provisions
provisional
provisionally
provocation
provoke
provoked
provokes
prow
prow's
prows
prowess
prowl
prowled
prowler
prowlers
prowling
proximal
proximate
proximity
prudence
prudent
prudently
prune
pruned
pruner
pruners
pruning
prunes
pry
priest
prying
psalm
psalm's
psalms
pseudo
psyche
psyche's
psyches
psychiatrist
psychiatrist's
psychiatrists
psychiatry
psychological
psychologically
psychologist
psychologist's
psychologists
psychology
psychosocial
pub
pub's
pubs
public
publicly
publication
publication's
publications
publicity
publicize
publicized
publicizing
publicizes
publish
published
publisher
publishers
publishing
publishes
pucker
puckered
puckering
puckers
pudding
pudding's
puddings
puddle
puddling
puddles
puff
puffed
puffing
puffs
pull
pulled
puller
pulling
pullings
pulls
pulley
pulley's
pulleys
pulp
pulping
pulpit
pulpit's
pulpits
pulse
pulsed
pulsing
pulses
pump
pumped
pumping
pumps
pumpkin
pumpkin's
pumpkins
pun
pun's
puns
punch
punched
puncher
punching
punches
punctual
punctually
punctuation
puncture
punctured
puncture's
puncturing
punctures
punish
punished
punishing
punishes
punishable
punishment
punishment's
punishments
punitive
punt
punted
punting
punts
puny
pup
pup's
pups
pupa
pupil
pupil's
pupils
puppet
puppet's
puppets
puppy
puppy's
puppies
purchase
purchased
purchaser
purchasers
purchasing
purchases
purchaseable
pure
purest
purer
purely
purge
purged
purging
purges
purify
purified
purifier
purifiers
purifying
purification
purifications
purifies
purity
purple
purplest
purpler
purport
purported
purporter
purporters
purporting
purports
purportedly
purpose
purposed
purposive
purposely
purposes
purposeful
purposefully
purr
purred
purring
purrs
purse
pursed
purser
purses
pursue
pursued
pursuer
pursuers
pursuing
pursues
pursuit
pursuit's
pursuits
purview
push
pushed
pusher
pushers
pushing
pushes
pushdown
puss
pussy
put
puts
putter
puttering
putters
putting
puzzle
puzzled
puzzler
puzzlers
puzzling
puzzlings
puzzles
puzzlement
pygmy
pygmy's
pygmies
pyramid
pyramid's
pyramids
quack
quacked
quacks
quadrant
quadrant's
quadrants
quadratic
quadratics
quadratical
quadratically
quadrature
quadrature's
quadratures
quadruple
quadrupled
quadrupling
quadruples
quagmire
quagmire's
quagmires
quail
quail's
quails
quaint
quaintness
quaintly
quake
quaked
quaker
quakers
quaking
quakes
qualify
qualified
qualifier
qualifiers
qualifying
qualification
qualifications
qualifies
qualitative
qualitatively
quality
quality's
qualities
quandary
quandary's
quandaries
quanta
quantifiable
quantify
quantified
quantifier
quantifiers
quantifying
quantification
quantifications
quantifies
quantitative
quantitatively
quantity
quantity's
quantities
quantization
quantize
quantized
quantizing
quantizes
quantum
quarantine
quarantine's
quarantines
quarrel
quarreled
quarreling
quarrels
quarrelsome
quarry
quarry's
quarries
quart
quarters
quarts
quarter
quartered
quartering
quarterly
quarters
quartet
quartet's
quartets
quartz
quash
quashed
quashing
quashes
quasi
quaver
quavered
quavering
quavers
quay
queen
queen's
queenly
queens
queer
queerness
queerest
queerer
queerly
quell
quelling
quench
quenched
quenching
quenches
query
queried
querying
queries
quest
quested
quester
questers
questing
quests
question
questioned
questioner
questioners
questioning
questionings
questions
questionable
questionably
questioningly
questionnaire
questionnaire's
questionnaires
queue
queued
queuer
queuers
queuing
queues
queueing
quick
quickness
quickest
quicker
quicken
quickens
quickly
quickened
quickening
quicksilver
quiet
quietness
quieted
quietest
quieter
quieting
quietly
quiets
quietude
quill
quilt
quilted
quilting
quilts
quinine
quit
quits
quite
quitter
quitter's
quitters
quitting
quiver
quivered
quivering
quivers
quiz
quizzed
quizzes
quizzing
quo
quoth
quota
quota's
quotas
quotation
quotation's
quotations
quote
quoted
quoting
quotes
quotient
rabbit
rabbit's
rabbits
rabble
raccoon
raccoon's
raccoons
race
raced
racer
racers
racing
races
racial
racially
rack
racked
racking
racks
racket
racket's
rackets
racketeer
racketeering
racketeers
radar
radar's
radars
radial
radially
radiance
radiant
radiantly
radiate
radiated
radiating
radiation
radiations
radiates
radiator
radiator's
radiators
radical
radically
radicals
radio
radioed
radioing
radios
radiology
radish
radish's
radishes
radius
radix
raft
rafter
rafters
rafts
rag
rag's
rags
rage
raged
raging
rages
ragged
raggedness
raggedly
raid
raided
raider
raiders
raiding
raids
rail
railed
railer
railers
railing
rails
railroad
railroaded
railroader
railroaders
railroading
railroads
railway
railway's
railways
raiment
rain
rained
raining
rains
rainbow
raincoat
raincoat's
raincoats
raindrop
raindrop's
raindrops
rainfall
rainy
rainiest
rainier
raise
raised
raiser
raisers
raising
raises
raisin
rake
raked
raking
rakes
rally
rallied
rallying
rallies
ram
ram's
rams
ramble
rambler
rambling
ramblings
rambles
ramification
ramification's
ramifications
ramp
ramp's
ramps
rampart
ran
ranch
ranched
rancher
ranchers
ranching
ranches
random
randomness
randomly
rang
range
ranged
ranger
rangers
ranging
ranges
rank
rankness
ranked
rankest
rankly
ranks
ranker
ranker's
rankers
ranking
ranking's
rankings
ransack
ransacked
ransacking
ransacks
ransom
ransomer
ransoming
ransoms
rant
ranted
ranter
ranters
ranting
rants
rap
rap's
raps
rape
raped
raper
raping
rapes
rapid
rapidly
rapids
rapidity
rapt
raptly
rapture
rapture's
raptures
rapturous
rare
rareness
rarest
rarer
rarely
rarety
rarety's
rareties
rarity
rascal
rascally
rascals
rash
rashness
rasher
rashly
rasp
rasped
rasping
rasps
raspberry
rat
rat's
rats
rate
rated
rater
raters
rating
ration
rations
ratings
rates
rather
ratify
ratified
ratifying
ratification
ratifies
ratio
ratio's
ratios
rational
rationally
rationale
rationale's
rationales
rationality
rationalities
rationalize
rationalized
rationalizing
rationalizes
rattle
rattled
rattler
rattlers
rattling
rattles
rattlesnake
rattlesnake's
rattlesnakes
ravage
ravaged
ravager
ravagers
ravaging
ravages
rave
raved
raving
ravings
raves
raven
ravening
ravens
ravenous
ravenously
ravine
ravine's
ravines
raw
rawness
rawest
rawer
rawly
ray
ray's
rays
razor
razor's
razors
re
red
rely
rings
reabbreviate
reabbreviated
reabbreviating
reabbreviates
reach
reached
reacher
reaching
reaches
reachable
reachably
react
reacted
reacting
reactive
reacts
reaction
reaction's
reactions
reactionary
reactionary's
reactionaries
reactivate
reactivated
reactivating
reactivation
reactivates
reactively
reactivity
reactor
reactor's
reactors
read
reader
readers
reading
readings
reads
readability
readable
readily
readjusted
readout
readout's
readouts
ready
readiness
readied
readiest
readier
readying
readies
real
realness
realest
realer
really
reals
realign
realigned
realigning
realigns
realism
realist
realist's
realists
realistic
realistically
reality
realities
realizable
realizably
realization
realization's
realizations
realize
realized
realizing
realizes
realm
realm's
realms
reanalyze
reanalyzing
reanalyzes
reap
reaped
reaper
reaping
reaps
reappear
reappeared
reappearing
reappears
reappraisal
reappraisals
rear
reared
rearing
rears
rearrange
rearranged
rearranging
rearranges
rearrangeable
rearrangement
rearrangement's
rearrangements
rearrest
rearrested
reason
reasoned
reasoner
reasoning
reasonings
reasons
reasonable
reasonableness
reasonably
reassemble
reassembled
reassembling
reassembles
reassessment
reassessment's
reassessments
reassign
reassigned
reassigning
reassigns
reassignment
reassignment's
reassignments
reassure
reassured
reassuring
reassures
reawaken
reawakened
reawakening
reawakens
rebate
rebate's
rebates
rebel
rebel's
rebels
rebellion
rebellion's
rebellions
rebellious
rebelliousness
rebelliously
rebound
rebounded
rebounding
rebounds
rebroadcast
rebuff
rebuffed
rebuild
rebuilding
rebuilds
rebuilt
rebuke
rebuked
rebuking
rebukes
rebuttal
recalculate
recalculated
recalculating
recalculation
recalculations
recalculates
recall
recalled
recalling
recalls
recapitulate
recapitulated
recapitulation
recapitulates
recapture
recaptured
recapturing
recaptures
recast
recasting
recasts
recede
receded
receding
recedes
receipt
receipt's
receipts
receivable
receive
received
receiver
receivers
receiving
receives
recent
recentness
recently
receptacle
receptacle's
receptacles
reception
reception's
receptions
receptive
receptiveness
receptively
receptivity
recess
recessed
recessive
recesses
recession
recipe
recipe's
recipes
recipient
recipient's
recipients
reciprocal
reciprocally
reciprocate
reciprocated
reciprocating
reciprocation
reciprocates
reciprocity
recirculate
recirculated
recirculating
recirculates
recital
recital's
recitals
recitation
recitation's
recitations
recite
recited
reciter
reciting
recites
reckless
recklessness
recklessly
reckon
reckoned
reckoner
reckoning
reckonings
reckons
reclaim
reclaimed
reclaimer
reclaimers
reclaiming
reclaims
reclaimable
reclamation
reclamations
reclassify
reclassified
reclassifying
reclassification
reclassifies
recline
reclining
recode
recoded
recoding
recodes
recognition
recognition's
recognitions
recognizability
recognizable
recognizably
recognize
recognized
recognizer
recognizers
recognizing
recognizes
recoil
recoiled
recoiling
recoils
recollect
recollected
recollecting
recollection
recollection's
recollections
recombine
recombined
recombining
recombines
recommend
recommended
recommender
recommending
recommends
recommendation
recommendation's
recommendations
recompense
recompute
recomputed
recomputing
recomputes
reconcile
reconciled
reconciler
reconciling
reconciles
reconciliation
reconfigurable
reconfiguration
reconfiguration's
reconfigurations
reconfigure
reconfigured
reconfigurer
reconfiguring
reconfigures
reconnect
reconnected
reconnecting
reconnects
reconnection
reconsider
reconsidered
reconsidering
reconsiders
reconsideration
reconstruct
reconstructed
reconstructing
reconstructs
reconstruction
record
recorded
recorder
recorders
recording
recordings
records
recount
recounted
recounting
recounts
recourse
recover
recovered
recovering
recovers
recoverable
recovery
recovery's
recoveries
recreate
recreated
recreating
recreation
recreations
recreative
recreates
recreation
recreations
recreational
recruit
recruited
recruiter
recruit's
recruiting
recruits
recta
rectangle
rectangle's
rectangles
rectangular
rector
rector's
rectors
rectum
rectum's
rectums
recur
recurs
recurrence
recurrence's
recurrences
recurrent
recurrently
recurring
recurse
recursed
recursing
recursion
recurses
recursion
recursion's
recursions
recursive
recursively
recyclable
recycle
recycled
recycling
recycles
red
redness
redly
reds
redbreast
redden
reddened
redder
reddest
reddish
reddishness
redeclare
redeclared
redeclaring
redeclares
redeem
redeemed
redeemer
redeemers
redeeming
redeems
redefine
redefined
redefining
redefines
redefinition
redefinition's
redefinitions
redemption
redesign
redesigned
redesigning
redesigns
redevelopment
redirecting
redirection
redirections
redisplay
redisplayed
redisplaying
redisplays
redistribute
redistributed
redistributing
redistributes
redone
redouble
redoubled
redraw
redrawn
redress
redressed
redressing
redresses
reduce
reduced
reducer
reducers
reducing
reduces
reducibility
reducible
reducibly
reduction
reduction's
reductions
redundancy
redundancies
redundant
redundantly
reed
reed's
reeds
reeducation
reef
reefer
reefs
reel
reeled
reeler
reeling
reels
reelect
reelected
reelecting
reelects
reemphasize
reemphasized
reemphasizing
reemphasizes
reenforcement
reenter
reentered
reentering
reenters
reentrant
reestablish
reestablished
reestablishing
reestablishes
reevaluate
reevaluated
reevaluating
reevaluation
reevaluates
reexamine
reexamined
reexamining
reexamines
refer
refers
referee
refereed
referees
refereeing
reference
referenced
referencer
referencing
references
referendum
referent
referent's
referents
referential
referentially
referentiality
referral
referral's
referrals
referred
referring
refill
refilled
refilling
refills
refillable
refine
refined
refiner
refining
refines
refinement
refinement's
refinements
reflect
reflected
reflecting
reflective
reflects
reflection
reflection's
reflections
reflectively
reflectivity
reflector
reflector's
reflectors
reflex
reflex's
reflexes
reflexive
reflexiveness
reflexively
reflexivity
reform
reformed
reformer
reformers
reforming
reforms
reformable
reformat
reformats
reformation
reformatted
reformatting
reformulate
reformulated
reformulating
reformulation
reformulates
refractory
refrain
refrained
refraining
refrains
refresh
refreshed
refresher
refreshers
refreshing
refreshes
refreshingly
refreshment
refreshment's
refreshments
refrigerator
refrigerator's
refrigerators
refuel
refueled
refueling
refuels
refuge
refugee
refugee's
refugees
refusal
refuse
refused
refusing
refuses
refutable
refutation
refute
refuted
refuter
refuting
refutes
regain
regained
regaining
regains
regal
regaled
regally
regard
regarded
regarding
regards
regardless
regenerate
regenerated
regenerating
regeneration
regenerative
regenerates
regent
regent's
regents
regime
regime's
regimes
regimen
regiment
regimented
regiments
region
region's
regions
regional
regionally
register
registered
registering
registers
registration
registration's
registrations
regress
regressed
regressing
regressive
regresses
regression
regression's
regressions
regret
regrets
regretful
regretfully
regrettable
regrettably
regretted
regretting
regroup
regrouped
regrouping
regular
regularly
regulars
regularity
regularities
regulate
regulated
regulating
regulation
regulations
regulative
regulates
regulator
regulator's
regulators
rehearsal
rehearsal's
rehearsals
rehearse
rehearsed
rehearser
rehearsing
rehearses
reign
reigned
reigning
reigns
reimbursed
reimbursement
reimbursement's
reimbursements
rein
reined
reins
reincarnate
reincarnated
reincarnation
reindeer
reinforce
reinforced
reinforcer
reinforcing
reinforces
reinforcement
reinforcement's
reinforcements
reinsert
reinserted
reinserting
reinserts
reinstate
reinstated
reinstating
reinstates
reinstatement
reinterpret
reinterpreted
reinterpreting
reinterprets
reintroduce
reintroduced
reintroducing
reintroduces
reinvent
reinvented
reinventing
reinvents
reiterate
reiterated
reiterating
reiteration
reiterates
reject
rejected
rejecting
rejects
rejection
rejection's
rejections
rejector
rejector's
rejectors
rejoice
rejoiced
rejoicer
rejoicing
rejoices
rejoin
rejoined
rejoining
rejoins
relabel
relabeled
relabeling
relabels
relapse
relate
related
relater
relating
relation
relations
relates
relational
relationally
relationship
relationship's
relationships
relative
relativeness
relatively
relatives
relativism
relativistic
relativistically
relativity
relax
relaxed
relaxer
relaxing
relaxes
relaxation
relaxation's
relaxations
relay
relayed
relaying
relays
release
released
releasing
releases
relegate
relegated
relegating
relegates
relent
relented
relenting
relents
relentless
relentlessness
relentlessly
relevance
relevances
relevant
relevantly
reliability
reliable
reliableness
reliably
reliance
relic
relic's
relics
relief
relieve
relieved
reliever
relievers
relieving
relieves
religion
religion's
religions
religious
religiousness
religiously
relinquish
relinquished
relinquishing
relinquishes
relish
relished
relishing
relishes
relive
reliving
relives
reload
reloaded
reloader
reloading
reloads
relocate
relocated
relocating
relocation
relocations
relocates
reluctance
reluctant
reluctantly
rely
relied
relying
relies
remain
remained
remaining
remains
remainder
remainder's
remainders
remark
remarked
remarking
remarks
remarkable
remarkableness
remarkably
remedy
remedied
remedying
remedies
remember
remembered
remembering
remembers
remembrance
remembrance's
remembrances
remind
reminded
reminder
reminders
reminding
reminds
reminiscence
reminiscence's
reminiscences
reminiscent
reminiscently
remittance
remnant
remnant's
remnants
remodel
remodeled
remodeling
remodels
remonstrate
remonstrated
remonstrating
remonstration
remonstrative
remonstrates
remorse
remote
remoteness
remotest
remoter
remotely
removable
removal
removal's
removals
remove
removed
remover
removing
removes
renaissance
renal
rename
renamed
renaming
renames
rend
renders
rending
rends
render
rendered
rendering
renderings
renders
rendezvous
rendition
rendition's
renditions
renew
renewed
renewer
renewing
renews
renewal
renounce
renouncing
renounces
renown
renowned
rent
rented
renting
rents
rental
rental's
rentals
renumber
renumbering
renumbers
reopen
reopened
reopening
reopens
reorder
reordered
reordering
reorders
reorganization
reorganization's
reorganizations
reorganize
reorganized
reorganizing
reorganizes
repaid
repair
repaired
repairer
repairing
repairs
repairman
reparation
reparation's
reparations
repast
repast's
repasts
repay
repayed
repaying
repays
repeal
repealed
repealer
repealing
repeals
repeat
repeated
repeater
repeaters
repeating
repeats
repeatable
repeatedly
repel
repels
repent
repented
repenting
repents
repentance
repercussion
repercussion's
repercussions
repertoire
repetition
repetition's
repetitions
repetitive
repetitiveness
repetitively
rephrase
rephrased
rephrasing
rephrases
repine
replace
replaced
replacer
replacing
replaces
replaceable
replacement
replacement's
replacements
replay
replayed
replaying
replays
replenish
replenished
replenishing
replenishes
replete
repleteness
repletion
replica
replicate
replicated
replicating
replication
replicates
reply
replied
replying
replication
replications
replies
report
reported
reporter
reporters
reporting
reports
reportedly
repose
reposed
reposing
reposes
reposition
repositioned
repositioning
repositions
repository
repository's
repositories
represent
represented
representing
represents
representable
representably
representation
representation's
representations
representational
representationally
representative
representativeness
representatively
representatives
repress
repressed
repressing
repressive
represses
repression
repression's
repressions
reprieve
reprieved
reprieving
reprieves
reprint
reprinted
reprinting
reprints
reprisal
reprisal's
reprisals
reproach
reproached
reproaching
reproaches
reproduce
reproduced
reproducer
reproducers
reproducing
reproduces
reproducibility
reproducibilities
reproducible
reproducibly
reproduction
reproduction's
reproductions
reprogram
reprograms
reprogrammed
reprogramming
reproof
reprove
reprover
reptile
reptile's
reptiles
republic
republic's
republics
republican
republican's
republicans
repudiate
repudiated
repudiating
repudiation
repudiations
repudiates
repulse
repulsed
repulsing
repulsion
repulsions
repulsive
repulses
reputable
reputably
reputation
reputation's
reputations
repute
reputed
reputes
reputedly
request
requested
requester
requesters
requesting
requests
require
required
requiring
requires
requirement
requirement's
requirements
requisite
requisitions
requisites
requisition
requisitioned
requisitioning
requisitions
reread
reroute
rerouted
rerouting
reroutes
rescue
rescued
rescuer
rescuers
rescuing
rescues
research
researched
researcher
researchers
researching
researches
reselect
reselected
reselecting
reselects
resemblance
resemblance's
resemblances
resemble
resembled
resembling
resembles
resent
resented
resenting
resents
resentful
resentfully
resentment
reservation
reservation's
reservations
reserve
reserved
reserver
reserving
reserves
reservoir
reservoir's
reservoirs
reset
resets
resetting
resettings
reside
resided
residing
resides
residence
residence's
residences
resident
resident's
residents
residential
residentially
residue
residue's
residues
resign
resigned
resigning
resigns
resignation
resignation's
resignations
resin
resin's
resins
resist
resisted
resisting
resistive
resists
resistable
resistably
resistance
resistances
resistant
resistantly
resistivity
resistor
resistor's
resistors
resolute
resoluteness
resolution
resolutions
resolutely
resolvable
resolve
resolved
resolver
resolvers
resolving
resolves
resonance
resonances
resonant
resort
resorted
resorting
resorts
resound
resounding
resounds
resource
resource's
resources
resourceful
resourcefulness
resourcefully
respect
respected
respecter
respecting
respective
respects
respectability
respectable
respectably
respectful
respectfulness
respectfully
respectively
respiration
respite
resplendent
resplendently
respond
responded
responder
responding
responds
respondent
respondent's
respondents
response
responsive
responses
responsibility
responsibilities
responsible
responsibleness
responsibly
responsively
responsiveness
rest
rested
resting
restive
rests
restart
restarted
restarting
restarts
restate
restated
restating
restates
restatement
restaurant
restaurant's
restaurants
restful
restfulness
restfully
restless
restlessness
restlessly
restoration
restoration's
restorations
restore
restored
restorer
restorers
restoring
restores
restrain
restrained
restrainer
restrainers
restraining
restrains
restraint
restraint's
restraints
restrict
restricted
restricting
restrictive
restricts
restriction
restriction's
restrictions
restrictively
restructure
restructured
restructuring
restructures
result
resulted
resulting
results
resultant
resultantly
resultants
resumable
resume
resumed
resuming
resumes
resumption
resumption's
resumptions
resurrect
resurrected
resurrecting
resurrects
resurrection
resurrection's
resurrections
resurrector
resurrectors
retail
retailer
retailers
retailing
retain
retained
retainer
retainers
retaining
retains
retainment
retaliation
retard
retarded
retarder
retarding
retention
retentions
retentive
retentiveness
retentively
reticle
reticle's
reticles
reticular
reticulate
reticulated
reticulating
reticulation
reticulately
reticulates
retina
retina's
retinas
retinal
retinue
retire
retired
retiring
retires
retirement
retirement's
retirements
retort
retorted
retorts
retrace
retraced
retracing
retract
retracted
retracting
retracts
retraction
retractions
retrain
retrained
retraining
retrains
retransmission
retransmission's
retransmissions
retransmit
retransmits
retransmitted
retransmitting
retreat
retreated
retreating
retreats
retrievable
retrieval
retrieval's
retrievals
retrieve
retrieved
retriever
retrievers
retrieving
retrieves
retroactively
retrospect
retrospective
retrospection
retry
retried
retrier
retriers
retrying
retries
return
returned
returner
returning
returns
returnable
retype
retyped
retyping
retypes
reunion
reunion's
reunions
reunite
reunited
reuniting
reusable
reuse
reused
reusing
reuses
revamp
revamped
revamping
revamps
reveal
revealed
revealing
reveals
revel
reveled
reveler
reveling
revels
revelation
revelation's
revelations
revelry
revenge
revenger
revenue
revenuers
revenues
revere
revered
revering
reveres
reverence
reverend
reverend's
reverends
reverently
reverify
reverified
reverifying
reverifies
reversal
reversal's
reversals
reverse
reversed
reverser
reversing
reversion
reversely
reverses
reversible
revert
reverted
reverting
reverts
review
reviewed
reviewer
reviewers
reviewing
reviews
revile
reviled
reviler
reviling
revise
revised
reviser
revising
revision
revisions
revises
revision
revision's
revisions
revisit
revisited
revisiting
revisits
revival
revival's
revivals
revive
revived
reviver
reviving
revives
revocation
revoke
revoked
revoker
revoking
revokes
revolt
revolted
revolter
revolting
revolts
revoltingly
revolution
revolution's
revolutions
revolutionary
revolutionary's
revolutionaries
revolutionize
revolutionized
revolutionizer
revolve
revolved
revolver
revolvers
revolving
revolves
reward
rewarded
rewarding
rewards
rewardingly
rewind
rewinding
rewinds
rework
reworked
reworking
reworks
rewound
rewrite
rewriting
rewrites
rewritten
rhetoric
rheumatism
rhinoceros
rhubarb
rhyme
rhymed
rhyming
rhymes
rhythm
rhythm's
rhythms
rhythmic
rhythmically
rib
rib's
ribs
ribbed
ribbing
ribbon
ribbon's
ribbons
rice
rich
richness
richest
richer
richly
riches
rickshaw
rickshaw's
rickshaws
rid
ridden
riddle
riddled
riddling
riddles
ride
rider
riders
riding
rides
ridge
ridge's
ridges
ridicule
ridiculed
ridiculing
ridicules
ridiculous
ridiculousness
ridiculously
rifle
rifled
rifler
rifling
rifles
rifleman
rift
rig
rig's
rigs
rigging
right
rightness
righted
righter
righting
rightly
rights
righteous
righteousness
righteously
rightful
rightfulness
rightfully
rightmost
rightward
rigid
rigidly
rigidity
rigor
rigors
rigorous
rigorously
rill
rim
rim's
rims
rime
rind
rind's
rinds
ring
ringed
ringer
ringers
ringing
ringings
rings
ringingly
rinse
rinsed
rinser
rinsing
rinses
riot
rioted
rioter
rioters
rioting
riots
riotous
rip
ripen
rips
ripe
ripeness
ripely
ripped
ripping
ripple
rippled
rippling
ripples
rise
riser
risers
rising
risings
rises
risen
risk
risked
risking
risks
rite
rite's
rites
ritual
ritually
rituals
rival
rivaled
rivals
rivalled
rivalling
rivalry
rivalry's
rivalries
river
river's
rivers
riverside
rivet
riveter
rivets
rivulet
rivulet's
rivulets
road
road's
roads
roadside
roadster
roadster's
roadsters
roadway
roadway's
roadways
roam
roamed
roaming
roams
roar
roared
roarer
roaring
roars
roast
roasted
roaster
roasting
roasts
rob
robs
robbed
robber
robber's
robbers
robbery
robbery's
robberies
robbing
robe
robed
robing
robes
robin
robin's
robins
robot
robot's
robots
robotic
robust
robustness
robustly
rock
rocked
rocker
rockers
rocking
rocks
rocket
rocketed
rocketing
rockets
rocky
rockies
rod
rod's
rods
rode
roe
rogue
rogue's
rogues
role
role's
roles
roll
rolled
roller
rollers
rolling
rolls
romance
romancer
romancers
romancing
romances
romantic
romantic's
romantics
romp
romped
romper
romping
romps
roof
roofed
roofer
roofing
roofs
rook
room
roomed
roomer
roomers
rooming
rooms
roost
rooster
roosters
root
rooted
rooter
root's
rooting
roots
rope
roped
roper
ropers
roping
ropes
rose
rose's
roses
rosebud
rosebud's
rosebuds
rosy
rosiness
rot
rots
rotary
rotate
rotated
rotating
rotation
rotations
rotates
rotator
rotten
rottenness
rouge
rough
roughness
roughed
roughest
rougher
roughen
roughly
round
roundness
rounded
roundest
rounder
rounding
roundly
rounds
roundabout
roundedness
roundoff
rouse
roused
rousing
rouses
rout
route
routed
router
routers
routing
routings
routes
routine
routinely
routines
rove
roved
rover
roving
roves
row
rowed
rower
rowing
rows
royal
royally
royalist
royalist's
royalists
royalty
royalty's
royalties
rub
rubens
rubs
rubbed
rubber
rubber's
rubbers
rubbing
rubbish
rubble
ruble
ruble's
rubles
rubout
ruby
ruby's
rubies
rudder
rudder's
rudders
ruddy
ruddiness
rude
rudeness
rudely
rudiment
rudiment's
rudiments
rudimentary
rue
ruefully
ruffian
ruffianly
ruffians
ruffle
ruffled
ruffles
rug
rug's
rugs
rugged
ruggedness
ruggedly
ruin
ruined
ruining
ruins
ruination
ruination's
ruinations
ruinous
ruinously
rule
ruled
ruler
rulers
ruling
rulings
rules
rum
rumen
rumble
rumbled
rumbler
rumbling
rumbles
rumor
rumored
rumors
rump
rumply
rumple
rumpled
run
runs
runaway
rung
rung's
rungs
runner
runner's
runners
running
runtime
rupture
ruptured
rupturing
ruptures
rural
rurally
rush
rushed
rusher
rushing
rushes
russet
Russian
Russian's
russians
rust
rusted
rusting
rusts
rustic
rusticate
rusticated
rusticating
rustication
rusticates
rustle
rustled
rustler
rustlers
rustling
rusty
rut
rut's
ruts
ruthless
ruthlessness
ruthlessly
rye
saber
saber's
sabers
sable
sable's
sables
sabotage
sack
sacker
sacking
sacks
sacred
sacredness
sacredly
sacrifice
sacrificed
sacrificer
sacrificers
sacrificing
sacrifices
sacrificial
sacrificially
sad
sadness
sadly
sadden
saddened
saddens
sadder
saddest
saddle
saddled
saddles
sadism
sadist
sadist's
sadists
sadistic
sadistically
safe
safeness
safest
safer
safely
safes
safeguard
safeguarded
safeguarding
safeguards
safety
safeties
sag
sags
sagacious
sagacity
sage
sagely
sages
said
sail
sailed
sailing
sails
sailor
sailorly
sailors
saint
sainted
saintly
saints
sake
sakes
salable
salad
salad's
salads
salary
salaried
salaries
sale
sale's
sales
salesman
salesmen
salient
saline
saliva
sallow
sally
sallying
sallies
salmon
salon
salon's
salons
saloon
saloon's
saloons
salt
salted
salter
salters
salting
salts
salty
saltiness
saltiest
saltier
salutary
salutation
salutation's
salutations
salute
saluted
saluting
salutes
salvage
salvaged
salvager
salvaging
salvages
salvation
salve
salver
salves
same
sameness
sample
sampled
sampler
samplers
sampling
samplings
samples
sanctify
sanctified
sanctification
sanction
sanctioned
sanctioning
sanctions
sanctity
sanctuary
sanctuary's
sanctuaries
sand
sanded
sander
sanders
sanding
sands
sandal
sandal's
sandals
sandpaper
sandstone
sandwich
sandwiches
sandy
sane
sanest
saner
sanely
sang
sanguine
sanitarium
sanitary
sanitation
sanity
sank
sap
sap's
saps
sapling
sapling's
saplings
sapphire
sarcasm
sarcasm's
sarcasms
sarcastic
sash
sat
satchel
satchel's
satchels
sate
sated
sating
sates
satellite
satellite's
satellites
satin
satire
satire's
satires
satisfaction
satisfaction's
satisfactions
satisfactorily
satisfactory
satisfiability
satisfiable
satisfy
satisfied
satisfying
satisfies
saturate
saturated
saturating
saturation
saturates
Saturday
Saturday's
Saturdays
satyr
sauce
saucer
saucers
sauces
saucepan
saucepan's
saucepans
saucy
saunter
sausage
sausage's
sausages
savage
savageness
savaged
savager
savagers
savaging
savagely
savages
save
saved
saver
savers
saving
savings
saves
savior
savior's
saviors
savor
savored
savoring
savors
savory
saw
sawed
sawing
saws
sawmill
sawmill's
sawmills
sawtooth
say
sayer
sayers
saying
sayings
says
scabbard
scabbard's
scabbards
scaffold
scaffolding
scaffoldings
scaffolds
scalable
scalar
scalar's
scalars
scald
scalded
scalding
scale
scaled
scaling
scalings
scales
scallop
scalloped
scallops
scalp
scalp's
scalps
scaly
scamper
scampering
scampers
scan
scans
scandal
scandal's
scandals
scandalous
scanned
scanner
scanner's
scanners
scanning
scant
scantly
scantily
scanty
scantiness
scantiest
scantier
scar
scar's
scars
scarce
scarceness
scarcely
scarcity
scare
scared
scaring
scares
scarf
scarlet
scary
scatter
scattered
scattering
scatters
scenario
scenario's
scenarios
scene
scene's
scenes
scenery
scenic
scent
scented
scents
scepter
scepter's
scepters
schedule
scheduled
scheduler
schedulers
scheduling
schedules
schema
schema's
schemas
schemata
schematic
schematically
scheme
schemed
schemer
schemers
scheming
schemes
scheme's
schizophrenia
scholar
scholarly
scholars
scholarship
scholarship's
scholarships
scholastic
scholastics
scholastically
school
schooled
schooler
schoolers
schooling
schools
schoolboy
schoolboy's
schoolboys
schoolhouse
schoolhouse's
schoolhouses
schoolmaster
schoolmaster's
schoolmasters
schoolroom
schoolroom's
schoolrooms
schooner
science
science's
sciences
scientific
scientifically
scientist
scientist's
scientists
scissor
scissored
scissoring
scissors
scoff
scoffed
scoffer
scoffing
scoffs
scold
scolded
scolding
scolds
scoop
scooped
scooping
scoops
scope
scoped
scoping
scopes
scorch
scorched
scorcher
scorching
scorches
score
scored
scorer
scorers
scoring
scorings
scores
scorn
scorned
scorner
scorning
scorns
scornful
scornfully
scorpion
scorpion's
scorpions
Scotland
scoundrel
scoundrel's
scoundrels
scour
scoured
scouring
scours
scourge
scout
scouted
scouting
scouts
scow
scowl
scowled
scowling
scowls
scramble
scrambled
scrambler
scrambling
scrambles
scrap
scrap's
scraps
scrape
scraped
scraper
scrapers
scraping
scrapings
scrapes
scrapped
scratch
scratched
scratcher
scratchers
scratching
scratches
scratchpad
scratchpad's
scratchpads
scrawl
scrawled
scrawling
scrawls
scream
screamed
screamer
screamers
screaming
screams
screech
screeched
screeching
screeches
screen
screened
screening
screenings
screens
screw
screwed
screwing
screws
scribble
scribbled
scribbler
scribbles
scribe
scribing
scribes
script
script's
scripts
scripture
scriptures
scroll
scrolled
scrolling
scrolls
scrub
scruple
scrupulous
scrupulously
scrutinize
scrutinized
scrutinizing
scrutiny
scuffle
scuffled
scuffling
scuffles
sculpt
sculpted
sculpts
sculptor
sculptor's
sculptors
sculpture
sculptured
sculptures
scurry
scurried
scuttle
scuttled
scuttling
scuttles
scythe
scythe's
scythes
sea
sealy
seas
seaboard
seacoast
seacoast's
seacoasts
seal
sealed
sealer
sealing
seals
sealevel
seam
seamed
seaming
seamen
seams
seaman
seaport
seaport's
seaports
sear
seared
searing
sears
search
searched
searcher
searchers
searching
searchings
searches
searchingly
searing
searingly
seashore
seashore's
seashores
seaside
season
seasoned
seasoner
seasoners
seasoning
seasonings
seasons
seasonable
seasonably
seasonal
seasonally
seat
seated
seating
seats
seaward
seaweed
secede
seceded
seceding
secedes
secluded
seclusion
second
seconded
seconder
seconders
seconding
secondly
seconds
secondarily
secondary
secondhand
secrecy
secret
secretly
secrets
secretarial
secretary
secretary's
secretaries
secrete
secreted
secreting
secretion
secretions
secretive
secretes
secretively
sect
sect's
sects
section
sectioned
sectioning
sections
sectional
sector
sector's
sectors
secular
secure
secured
securing
securely
securings
secures
security
securities
sedge
sediment
sediment's
sediments
seduce
seduced
seducer
seducers
seducing
seduces
seductive
see
seer
seers
sees
seed
seeded
seeder
seeders
seeding
seedings
seeds
seedling
seedling's
seedlings
seeing
seek
seeker
seekers
seeking
seeks
seem
seemed
seeming
seemly
seems
seemingly
seen
seep
seeped
seeping
seeps
seethe
seethed
seething
seethes
segment
segmented
segmenting
segments
segmentation
segmentation's
segmentations
segregate
segregated
segregating
segregation
segregates
seismic
seize
seized
seizing
seizes
seizure
seizure's
seizures
seldom
select
selected
selecting
selective
selects
selection
selection's
selections
selective
selectively
selectivity
selector
selector's
selectors
self
selfish
selfishness
selfishly
selfsame
sell
seller
sellers
selling
sells
selves
semantic
semantics
semantical
semantically
semanticist
semanticist's
semanticists
semaphore
semaphore's
semaphores
semblance
semester
semester's
semesters
semiautomated
semicolon
semicolon's
semicolons
semiconductor
semiconductor's
semiconductors
seminal
seminar
seminar's
seminars
seminary
seminary's
seminaries
semipermanent
semipermanently
senate
senate's
senates
senator
senator's
senators
send
sender
senders
sending
sends
senior
senior's
seniors
seniority
sensation
sensation's
sensations
sensational
sensationally
sense
sensed
sensing
senses
senseless
senselessness
senselessly
sensibility
sensibilities
sensible
sensibly
sensitive
sensitiveness
sensitively
sensitives
sensitivity
sensitivities
sensor
sensor's
sensors
sensory
sent
sentence
sentenced
sentencing
sentences
sentential
sentiment
sentiment's
sentiments
sentimental
sentimentally
sentinel
sentinel's
sentinels
sentry
sentry's
sentries
separable
separate
separateness
separated
separating
separation
separations
separately
separates
separator
separator's
separators
September
sepulcher
sepulcher's
sepulchers
sequel
sequel's
sequels
sequence
sequenced
sequencer
sequencers
sequencing
sequencings
sequences
sequential
sequentially
sequentiality
sequentialize
sequentialized
sequentializing
sequentializes
sequester
serendipitous
serendipity
serene
serenely
serenity
serf
serf's
serfs
sergeant
sergeant's
sergeants
serial
serially
serials
serialization
serialization's
serializations
serialize
serialized
serializing
serializes
series
serious
seriousness
seriously
sermon
sermon's
sermons
serpent
serpent's
serpents
serpentine
serum
serum's
serums
servant
servant's
servants
serve
served
server
servers
serving
servings
serves
service
serviced
servicing
services
serviceable
servile
servitude
session
session's
sessions
set
set's
sets
setter
setter's
setters
setting
settings
settle
settled
settler
settlers
settling
settles
settlement
settlement's
settlements
setup
setups
seven
seventh
sevens
seventeen
seventeenth
seventeens
seventy
seventieth
seventies
sever
severs
several
severally
severance
severe
severed
severest
severer
severing
severely
severity
severity's
severities
sew
sewed
sewer
sewers
sewing
sews
sex
sexed
sexes
sexual
sexually
sexuality
shabby
shack
shacked
shacks
shackle
shackled
shackling
shackles
shade
shaded
shading
shadings
shades
shadily
shadow
shadowed
shadowing
shadows
shadowy
shady
shadiness
shadiest
shadier
shaft
shaft's
shafts
shaggy
shakable
shakably
shake
shaker
shakers
shaking
shakes
shaken
shaky
shakiness
shale
shall
shallow
shallowness
shallower
shallowly
sham
sham's
shams
shambles
shame
shamed
shaming
shames
shameful
shamefully
shameless
shamelessly
shan't
shanty
shanty's
shanties
shape
shaped
shaper
shapers
shaping
shapely
shapes
shapeless
shapelessness
shapelessly
sharable
share
shared
sharer
sharers
sharing
shares
shareable
sharecropper
sharecropper's
sharecroppers
shareholder
shareholder's
shareholders
shark
shark's
sharks
sharp
sharpness
sharpest
sharper
sharpen
sharpens
sharply
sharpened
sharpening
shatter
shattered
shattering
shatters
shave
shaved
shaving
shavings
shaves
shaven
shawl
shawl's
shawls
she
shed
she's
shes
she'll
sheaf
shear
sheared
shearer
shearing
shears
sheath
sheathing
sheaths
sheaves
shed
sheds
sheep
sheer
sheered
sheet
sheeted
sheeting
sheets
shelf
shell
shelled
sheller
shelling
shells
shelter
sheltered
sheltering
shelters
shelve
shelved
shelving
shelves
shepherd
shepherd's
shepherds
sheriff
sheriff's
sheriffs
shield
shielded
shielding
shields
shift
shifted
shifter
shifters
shifting
shifts
shiftily
shifty
shiftiness
shiftiest
shiftier
shilling
shillings
shimmer
shimmering
shin
shine
shined
shiner
shiners
shining
shines
shingle
shingle's
shingles
shiningly
shiny
ship
ship's
ships
shipboard
shipbuilding
shipment
shipment's
shipments
shipped
shipper
shipper's
shippers
shipping
shipwreck
shipwrecked
shipwrecks
shirk
shirker
shirking
shirks
shirt
shirting
shirts
shiver
shivered
shiverer
shivering
shivers
shoal
shoal's
shoals
shock
shocked
shocker
shockers
shocking
shocks
shockingly
shod
shoe
shoed
shoes
shoeing
shoemaker
shone
shook
shoot
shooter
shooters
shooting
shootings
shoots
shop
shop's
shops
shopkeeper
shopkeeper's
shopkeepers
shopped
shopper
shopper's
shoppers
shopping
shore
shore's
shores
shorn
short
shortness
shorted
shortest
shorter
shorting
shortly
shorts
shortage
shortage's
shortages
shortcoming
shortcoming's
shortcomings
shortcut
shortcut's
shortcuts
shorten
shortened
shortening
shortens
shorthand
shorthanded
shot
shot's
shots
shotgun
shotgun's
shotguns
should
shoulders
shoulder
shouldered
shouldering
shoulders
shouldn't
shout
shouted
shouter
shouters
shouting
shouts
shove
shoved
shoving
shoves
shovel
shoveled
shovels
show
showed
shower
showers
showing
showings
shows
shower
showered
showering
showers
shown
shrank
shred
shred's
shreds
shrew
shrew's
shrews
shrewd
shrewdness
shrewdest
shrewdly
shriek
shrieked
shrieking
shrieks
shrill
shrillness
shrilled
shrilling
shrilly
shrimp
shrine
shrine's
shrines
shrink
shrinking
shrinks
shrinkable
shrivel
shriveled
shroud
shrouded
shrub
shrub's
shrubs
shrubbery
shrug
shrugs
shrunk
shrunken
shudder
shuddered
shuddering
shudders
shuffle
shuffled
shuffling
shuffles
shun
shuns
shut
shuts
shutdown
shutdown's
shutdowns
shutter
shuttered
shutters
shutting
shuttle
shuttled
shuttling
shuttles
shy
shied
shyly
shies
shyness
sibling
sibling's
siblings
sick
sickest
sicker
sicken
sickly
sickle
sickness
sickness's
sicknesses
side
sided
siding
sidings
sides
sideboard
sideboard's
sideboards
sideburn
sideburn's
sideburns
sidelight
sidelight's
sidelights
sidewalk
sidewalk's
sidewalks
sideways
sidewise
siege
siege's
sieges
sierra
sieve
sieve's
sieves
sift
sifted
sifter
sifting
sigh
sighed
sighing
sighs
sight
sighted
sighting
sightly
sightings
sights
sign
signed
signer
signers
signing
signs
signal
signaled
signaling
signally
signals
signalled
signalling
signature
signature's
signatures
signet
significance
significant
significantly
significants
signify
signified
signifying
signification
signifies
signor
sikkim
silence
silenced
silencer
silencers
silencing
silences
silent
silently
silhouette
silhouetted
silhouettes
silicon
silicone
silk
silken
silks
silkily
silkine
silky
silkiest
silkier
sill
sill's
sills
silly
silliness
silliest
silt
silted
silting
silts
silver
silvered
silvering
silvers
silvery
similar
similarly
similarity
similarities
similitude
simmer
simmered
simmering
simmers
simple
simpleness
simplest
simpler
simplex
simplicity
simplicity's
simplicities
simplify
simplified
simplifier
simplifiers
simplifying
simplification
simplifications
simplifies
simplistic
simply
simulate
simulated
simulating
simulation
simulations
simulates
simulator
simulator's
simulators
simultaneity
simultaneous
simultaneously
sin
sin's
sins
since
sincere
sincerest
sincerely
sincerity
sine
sines
sinew
sinew's
sinews
sinful
sinfulness
sinfully
sing
singed
singer
singers
singing
singly
sings
singable
singingly
single
singleness
singled
singling
singles
singleton
singleton's
singletons
singular
singularly
singularity
singularity's
singularities
sinister
sink
sinked
sinker
sinkers
sinking
sinks
sinned
sinner
sinner's
sinners
sinning
sinusoidal
sinusoids
sip
sips
sir
siren
sirens
sirs
sire
sired
sires
sirup
sister
sisterly
sisters
sit
sits
site
sited
siting
sites
sitter
sitter's
sitters
sitting
sittings
situate
situated
situating
situation
situations
situates
situational
situationally
six
sixth
sixes
sixpence
sixteen
sixteenth
sixteens
sixty
sixtieth
sixties
sizable
size
sized
sizing
sizings
sizes
skate
skated
skater
skaters
skating
skates
skeletal
skeleton
skeleton's
skeletons
skeptic
skeptic's
skeptics
skeptical
skeptically
sketch
sketched
sketching
sketches
sketchily
sketchy
skew
skewed
skewer
skewers
skewing
skews
ski
skiing
skis
skill
skilled
skills
skillful
skillfulness
skillfully
skim
skim's
skims
skimp
skimped
skimping
skimps
skin
skin's
skins
skinned
skinner
skinner's
skinners
skinning
skip
skips
skipped
skipper
skipper's
skippers
skipping
skirmish
skirmished
skirmisher
skirmishers
skirmishing
skirmishes
skirt
skirted
skirting
skirts
skulk
skulked
skulker
skulking
skulks
skull
skull's
skulls
skunk
skunk's
skunks
sky
sky's
skies
skylark
skylarking
skylarks
skylight
skylight's
skylights
skyscraper
skyscraper's
skyscrapers
slab
slack
slackness
slacker
slacking
slacken
slackly
slacks
slain
slam
slams
slammed
slamming
slander
slanderer
slanders
slang
slant
slanted
slanting
slants
slap
slaps
slapped
slapping
slash
slashed
slashing
slashes
slat
slat's
slats
slate
slated
slater
slates
slaughter
slaughtered
slaughtering
slaughters
slave
slaver
slaves
slavery
slay
slayer
slayers
slaying
slays
sled
sled's
sleds
sledge
sledge's
sledges
sleek
sleep
sleeper
sleepers
sleeping
sleeps
sleepily
sleepless
sleeplessness
sleeplessly
sleepy
sleepiness
sleet
sleeve
sleeve's
sleeves
sleigh
sleighs
slender
slenderer
slept
slew
slewing
slice
sliced
slicer
slicers
slicing
slices
slick
slicker
slickers
slicks
slid
slide
slider
sliders
sliding
slides
slight
slightness
slighted
slightest
slighter
slighting
slightly
slights
slim
slimly
slime
slimed
slimy
sling
slinging
slings
slip
slip's
slips
slippage
slipped
slipper
slipper's
slippers
slippery
slipperiness
slipping
slit
slit's
slits
slogan
slogan's
slogans
slop
slops
slope
sloped
sloper
slopers
sloping
slopes
slopped
slopping
sloppy
sloppiness
slot
slot's
slots
sloth
sloths
slotted
slouch
slouched
slouching
slouches
slow
slowness
slowed
slowest
slower
slowing
slowly
slows
slug
slugs
sluggish
sluggishness
sluggishly
slum
slum's
slums
slumber
slumbered
slump
slumped
slumps
slung
slur
slur's
slurs
sly
slyly
smack
smacked
smacking
smacks
small
smallness
smallest
smaller
smallpox
smart
smartness
smarted
smartest
smarter
smartly
smash
smashed
smasher
smashers
smashing
smashes
smashingly
smear
smeared
smearing
smears
smell
smelled
smelling
smells
smelly
smelt
smelter
smelts
smile
smiled
smiling
smiles
smilingly
smite
smith
smiths
smithy
smitten
smock
smocking
smocks
smog
smokable
smoke
smoked
smoker
smokers
smoking
smokes
smoky
smokies
smolder
smoldered
smoldering
smolders
smooth
smoothness
smoothed
smoothest
smoother
smoothing
smoothly
smoothes
smote
smother
smothered
smothering
smothers
smuggle
smuggled
smuggler
smugglers
smuggling
smuggles
snail
snail's
snails
snake
snaked
snakes
snap
snaps
snapped
snapper
snapper's
snappers
snappily
snapping
snappy
snapshot
snapshot's
snapshots
snare
snared
snaring
snares
snarl
snarled
snarling
snatch
snatched
snatching
snatches
sneak
sneaked
sneaker
sneakers
sneaking
sneaks
sneakily
sneaky
sneakiness
sneakiest
sneakier
sneer
sneered
sneering
sneers
sneeze
sneezed
sneezing
sneezes
sniff
sniffed
sniffing
sniffs
snoop
snooped
snooping
snoops
snore
snored
snoring
snores
snort
snorted
snorting
snorts
snout
snout's
snouts
snow
snowed
snowing
snows
snowily
snowman
snowmen
snowshoe
snowshoe's
snowshoes
snowy
snowiest
snowier
snuff
snuffed
snuffer
snuffing
snuffs
snug
snugness
snugly
snuggle
snuggled
snuggling
snuggles
so
soak
soaked
soaking
soaks
soap
soaped
soaping
soaps
soar
soared
soaring
soars
sob
sober
sobs
sober
soberness
sobered
sobering
soberly
sobers
soccer
sociability
sociable
sociably
social
socially
socialism
socialist
socialist's
socialists
socialize
socialized
socializing
socializes
societal
society
society's
societies
sociological
sociologically
sociology
sock
socked
socking
socks
socket
socket's
sockets
sod
sod's
sods
soda
sodium
sodomy
sofa
sofa's
sofas
soft
softness
softest
softer
softens
softly
soften
softened
softening
softens
software
software's
softwares
soil
soiled
soiling
soils
sojourn
sojourner
sojourners
solace
solaced
solar
sold
solder
soldier
soldiering
soldierly
soldiers
sole
solely
soles
solemn
solemnness
solemnly
solemnity
solicit
solicited
soliciting
solicits
solicitor
solid
solidness
solidly
solids
solidify
solidified
solidifying
solidification
solidifies
solidity
solitaire
solitary
solitude
solitude's
solitudes
solo
solo's
solos
solubility
soluble
solution
solution's
solutions
solvable
solve
solved
solver
solvers
solving
solves
solvent
solvent's
solvents
somber
somberly
some
somebody
someday
somehow
someone
someone's
something
sometime
sometimes
somewhat
somewhere
son
son's
sons
sonar
song
song's
songs
sonnet
sonnet's
sonnets
soon
soonest
sooner
soot
sooth
soothe
soothed
soother
soothing
soothes
sophisticated
sophistication
sophomore
sophomore's
sophomores
sorcerer
sorcerer's
sorcerers
sorcery
sordid
sordidness
sordidly
sore
soreness
sorest
sorer
sorely
sores
sorrow
sorrow's
sorrows
sorrowful
sorrowfully
sorry
sorriest
sorrier
sort
sorted
sorter
sorters
sorting
sorts
sought
soul
soul's
souls
sound
soundness
sounded
soundest
sounder
soundly
sounds
sounding
sounding's
soundings
soup
soup's
soups
sour
sourness
soured
sourest
sourer
souring
sourly
sours
source
source's
sources
south
southern
southerner
southerners
sovereign
sovereign's
sovereigns
Soviet
Soviet's
Soviets
space
spaced
spacer
spacers
spacing
spacings
spaces
spaceship
spaceship's
spaceships
spade
spaded
spading
spades
spaghetti
spain
span
span's
spans
spanish
spank
spanked
spanking
spanks
spankingly
spanned
spanner
spanner's
spanners
spanning
spare
spareness
spared
sparest
sparer
sparing
sparely
spares
sparingly
spark
sparked
sparking
sparks
sparrow
sparrow's
sparrows
sparse
sparseness
sparsest
sparser
sparsely
spat
spate
spate's
spates
spatial
spatially
spatter
spattered
spawn
spawned
spawning
spawns
speak
speaker
speakers
speaking
speaks
speakable
spear
speared
spears
special
specially
specials
specialist
specialist's
specialists
specialization
specialization's
specializations
specialize
specialized
specializing
specializes
specialty
specialty's
specialties
species
specifiable
specific
specifics
specifically
specificity
specify
specified
specifier
specifiers
specifying
specification
specifications
specifies
specimen
specimen's
specimens
speck
speck's
specks
speckle
speckled
speckles
spectacle
spectacled
spectacles
spectacular
spectacularly
spectator
spectator's
spectators
specter
specter's
specters
spectra
spectrogram
spectrogram's
spectrograms
spectrum
speculate
speculated
speculating
speculation
speculations
speculative
speculates
speculator
speculator's
speculators
sped
speech
speech's
speeches
speechless
speechlessness
speed
speeded
speeder
speeders
speeding
speeds
speedily
speedup
speedup's
speedups
speedy
spell
spelled
speller
spellers
spelling
spellings
spells
spencer
spend
spender
spenders
spending
spends
spent
sphere
sphere's
spheres
spherical
spherically
spice
spiced
spices
spicy
spiciness
spider
spider's
spiders
spike
spiked
spikes
spill
spilled
spiller
spilling
spills
spin
spins
spinach
spinal
spinally
spindle
spindling
spine
spinner
spinner's
spinners
spinning
spiral
spiraled
spiraling
spirally
spire
spire's
spires
spirit
spirited
spiriting
spirits
spiritedly
spiritual
spiritually
spirituals
spit
spits
spite
spited
spiting
spites
spiteful
spitefulness
spitefully
splash
splashed
splashing
splashes
spleen
splendid
splendidly
splendor
splice
spliced
splicer
splicers
splicing
splicings
splices
spline
spline's
splines
splinter
splintered
splinters
split
split's
splits
splitter
splitter's
splitters
splitting
spoil
spoiled
spoiler
spoilers
spoiling
spoils
spoke
spoked
spokes
spoken
spokesman
spokesmen
sponge
sponged
sponger
spongers
sponging
sponges
sponsor
sponsored
sponsoring
sponsors
sponsorship
spontaneous
spontaneously
spook
spooky
spool
spooled
spooler
spooling
spools
spoon
spooned
spooning
spoons
spore
spore's
spores
sport
sported
sporting
sportive
sports
sportingly
sportsman
spot
spot's
spots
spotless
spotlessly
spotted
spotter
spotter's
spotters
spotting
spouse
spouse's
spouses
spout
spouted
spouting
spouts
sprang
sprawl
sprawled
sprawling
sprawls
spray
sprayed
sprayer
spraying
sprays
spread
spreader
spreaders
spreading
spreadings
spreads
spree
spree's
sprees
sprig
sprightly
spring
springer
springers
springing
springs
springtime
springy
springiness
springiest
springier
sprinkle
sprinkled
sprinkler
sprinkling
sprinkles
sprint
sprinted
sprinter
sprinters
sprinting
sprints
sprite
sprout
sprouted
sprouting
spruce
spruced
sprung
spun
spur
spur's
spurs
spurious
spurn
spurned
spurning
spurns
spurt
spurted
spurting
spurts
sputter
sputtered
spy
spying
spies
squabble
squabbled
squabbling
squabbles
squad
squad's
squads
squadron
squadron's
squadrons
squall
squall's
squalls
square
squareness
squared
squarest
squarer
squaring
squarely
squares
squash
squashed
squashing
squat
squats
squawk
squawked
squawking
squawks
squeak
squeaked
squeaking
squeaks
squeal
squealed
squealing
squeals
squeeze
squeezed
squeezer
squeezing
squeezes
squid
squint
squinted
squinting
squire
squire's
squires
squirm
squirmed
squirms
squirrel
squirreled
squirreling
squirrels
stab
stably
stabs
stabbed
stabbing
stability
stability's
stabilities
stabilize
stabilized
stabilizer
stabilizers
stabilizing
stabilizes
stable
stabled
stabler
stabling
stables
stack
stacked
stack's
stacking
stacks
staff
staffed
staffer
staffers
staffing
staffs
stag
stag's
stags
stage
staged
stager
stagers
staging
stages
stagecoach
stagger
staggered
staggering
staggers
stagnant
staid
stain
stained
staining
stains
stainless
stair
stair's
stairs
staircase
staircase's
staircases
stairway
stairway's
stairways
stake
staked
stakes
stale
stalk
stalked
stalking
stall
stalled
stalling
stallings
stalls
stalwart
stalwartly
stamen
stamen's
stamens
stamina
stammer
stammered
stammerer
stammering
stammers
stamp
stamped
stamper
stampers
stamping
stamps
stampede
stampeded
stampeding
stampedes
stanch
stanchest
stand
standing
standings
stands
standard
standardly
standards
standardization
standardize
standardized
standardizing
standardizes
standby
standpoint
standpoint's
standpoints
standstill
stanza
stanza's
stanzas
staple
stapler
stapling
staples
star
star's
stars
starboard
starch
starched
stare
stared
starer
staring
stares
starfish
stark
starkly
starlight
starred
starring
starry
start
started
starter
starters
starting
starts
startle
startled
startling
startles
startup
startup's
startups
starvation
starve
starved
starving
starves
state
stated
state's
stating
stations
stately
states
statement
statement's
statements
statesman
static
statically
station
stationed
stationer
stationing
stations
stationary
statistic
statistics
statistical
statistically
statistician
statistician's
statisticians
statue
statue's
statues
statuesque
statuesqueness
statuesquely
stature
status
statuses
statute
statute's
statutes
statutorily
statutory
statutoriness
staunch
staunchest
staunchly
stave
staved
staves
stay
stayed
staying
stays
stead
steadfast
steadfastness
steadfastly
steadily
steady
steadiness
steadied
steadiest
steadier
steadying
steadies
steak
steak's
steaks
steal
stealer
stealing
stealth
steals
stealthily
stealthy
steam
steamed
steamer
steamers
steaming
steams
steamboat
steamboat's
steamboats
steamship
steamship's
steamships
steed
steel
steeled
steelers
steeling
steels
steep
steepness
steeped
steepest
steeper
steeping
steeply
steeps
steeple
steeple's
steeples
steer
steered
steering
steers
stellar
stem
stem's
stems
stemmed
stemming
stench
stench's
stenches
stencil
stencil's
stencils
stenographer
stenographer's
stenographers
step
step's
steps
stepmother
stepmother's
stepmothers
stepped
stepping
stepwise
stereo
stereo's
stereos
stereotype
stereotyped
stereotypes
stereotypical
sterile
sterilization
sterilization's
sterilizations
sterilize
sterilized
sterilizer
sterilizing
sterilizes
sterling
stern
sternness
sternly
sterns
stew
stewed
stews
steward
steward's
stewards
stick
sticker
stickers
sticking
sticken
sticks
stickily
sticky
stickiness
stickiest
stickier
stiff
stiffness
stiffest
stiffer
stiffen
stiffens
stiffly
stiffs
stifle
stifled
stifling
stifles
stigma
stile
stile's
stiles
still
stillness
stilled
stillest
stiller
stilling
stills
stimulant
stimulant's
stimulants
stimulate
stimulated
stimulating
stimulation
stimulations
stimulative
stimulates
stimuli
stimulus
sting
stinging
stings
stink
stinker
stinkers
stinking
stinks
stint
stipend
stipend's
stipends
stipulate
stipulated
stipulating
stipulation
stipulations
stipulates
stir
stirs
stirred
stirrer
stirrer's
stirrers
stirring
stirringly
stirrings
stirrup
stitch
stitched
stitching
stitches
stochastic
stochastically
stock
stocked
stocker
stockers
stocking
stockings
stocks
stockade
stockade's
stockades
stockholder
stockholder's
stockholders
stole
stole's
stoles
stolen
stomach
stomached
stomacher
stomaching
stomaches
stone
stoned
stoning
stones
stony
stood
stool
stoop
stooped
stooping
stoops
stop
stops
stopcock
stopcocks
stoppable
stoppage
stopped
stopper
stopper's
stoppers
stopping
storage
storage's
storages
store
stored
storing
stores
storehouse
storehouse's
storehouses
stork
stork's
storks
storm
stormed
storming
storms
stormy
storminess
stormiest
stormier
story
storied
stories
stout
stoutness
stoutest
stouter
stoutly
stove
stove's
stoves
stow
stowed
straggle
straggled
straggler
stragglers
straggling
straggles
straight
straightness
straightest
straighter
straighten
straightens
straightforward
straightforwardness
straightforwardly
straightway
strain
strained
strainer
strainers
straining
strains
strait
straiten
straits
strand
stranded
stranding
strands
strange
strangeness
stranger
strangers
strangely
strangest
strangle
strangled
strangler
stranglers
strangling
stranglings
strangles
strangulation
strangulation's
strangulations
strap
strap's
straps
stratagem
stratagem's
stratagems
strategic
strategy
strategy's
strategies
stratify
stratified
stratification
stratifications
stratifies
stratum
straw
straw's
straws
strawberry
strawberry's
strawberries
stray
strayed
strays
streak
streaked
streaks
stream
streamed
streamer
streamers
streaming
streams
streamline
streamlined
streamliner
streamlining
streamlines
street
streeters
streets
streetcar
streetcar's
streetcars
strength
strengthen
strengthen
strengthened
strengthener
strengthening
strengthens
strengths
strenuous
strenuously
stress
stressed
stressing
stresses
stretch
stretched
stretcher
stretchers
stretching
stretches
strew
strews
strewn
strict
strictness
strictest
stricter
strictly
stride
strider
striding
strides
strife
strike
striker
strikers
striking
strikes
strikingly
string
stringed
stringer
stringers
stringing
strings
string's
stringent
stringently
stringy
stringiness
stringiest
stringier
strip
strip's
strips
stripe
striped
stripes
stripped
stripper
stripper's
strippers
stripping
strive
striving
strivings
strives
strode
stroke
stroked
stroker
strokers
stroking
strokes
stroll
strolled
stroller
strolling
strolls
strong
strongest
stronger
strongly
stronghold
strove
struck
structural
structurally
structure
structured
structurer
structuring
structures
struggle
struggled
struggling
struggles
strung
strut
struts
stub
stub's
stubs
stubble
stubborn
stubbornness
stubbornly
stuck
stud
stud's
studs
student
student's
students
studio
studio's
studios
studious
studiously
study
studied
studying
studies
stuff
stuffed
stuffing
stuffs
stuffy
stuffiest
stuffier
stumble
stumbled
stumbling
stumbles
stump
stumped
stumping
stumps
stun
stung
stunning
stunningly
stunt
stunt's
stunts
stupefy
stupefying
stupendous
stupendously
stupid
stupidest
stupidly
stupidity
stupidities
stupor
sturdy
sturdiness
style
styled
styler
stylers
styling
styles
stylish
stylishness
stylishly
stylistic
stylistically
stylized
sub
subs
subatomic
subclass
subclass's
subclasses
subcomponent
subcomponent's
subcomponents
subcomputation
subcomputation's
subcomputations
subconscious
subconsciously
subculture
subculture's
subcultures
subdivide
subdivided
subdividing
subdivides
subdivision
subdivision's
subdivisions
subdue
subdued
subduing
subdues
subexpression
subexpression's
subexpressions
subfield
subfield's
subfields
subfile
subfile's
subfiles
subgoal
subgoal's
subgoals
subgraph
subgraphs
subgroup
subgroup's
subgroups
subinterval
subinterval's
subintervals
subject
subjected
subjecting
subjective
subjects
subjection
subjectively
subjectivity
sublimation
sublimations
sublime
sublimed
sublist
sublist's
sublists
submarine
submariner
submariners
submarines
submerge
submerged
submerging
submerges
submission
submission's
submissions
submit
submits
submitted
submitting
submode
submodes
submodule
submodule's
submodules
subnetwork
subnetwork's
subnetworks
subordinate
subordinated
subordination
subordinates
subproblem
subproblem's
subproblems
subprogram
subprogram's
subprograms
subproject
subproof
subproof's
subproofs
subrange
subrange's
subranges
subroutine
subroutine's
subroutines
subschema
subschema's
subschemas
subscribe
subscribed
subscriber
subscribers
subscribing
subscribes
subscript
subscripted
subscripting
subscripts
subscription
subscription's
subscriptions
subsection
subsection's
subsections
subsegment
subsegment's
subsegments
subsequence
subsequence's
subsequences
subsequent
subsequently
subset
subset's
subsets
subside
subsided
subsiding
subsides
subsidiary
subsidiary's
subsidiaries
subsidize
subsidized
subsidizing
subsidizes
subsidy
subsidy's
subsidies
subsist
subsisted
subsisting
subsists
subsistence
subspace
subspace's
subspaces
substance
substance's
substances
substantial
substantially
substantiate
substantiated
substantiating
substantiation
substantiations
substantiates
substantive
substantively
substantivity
substitutability
substitutable
substitute
substituted
substituting
substitution
substitutions
substitutes
substrate
substrate's
substrates
substring
substrings
substructure
substructure's
substructures
subsume
subsumed
subsuming
subsumes
subsystem
subsystem's
subsystems
subtask
subtask's
subtasks
subterranean
subtitle
subtitles
subtle
subtleness
subtlest
subtler
subtlety
subtleties
subtly
subtract
subtracted
subtracting
subtracts
subtraction
subtractions
subtractor
subtractor's
subtractors
subtrahend
subtrahend's
subtrahends
subtree
subtree's
subtrees
subunit
subunit's
subunits
suburb
suburb's
suburbs
suburban
subversion
subvert
subverted
subverter
subverting
subverts
subway
subway's
subways
succeed
succeeded
succeeding
succeeds
success
successive
successes
successful
successfully
succession
succession's
successions
successively
successor
successor's
successors
succinct
succinctness
succinctly
succor
succumb
succumbed
succumbing
succumbs
such
suck
sucked
sucker
suckers
sucking
sucks
suckle
suckling
suction
sudden
suddenness
suddenly
suds
sudsing
sue
sued
suing
sues
suffer
suffered
sufferer
sufferers
suffering
sufferings
suffers
sufferance
suffice
sufficed
sufficing
suffices
sufficiency
sufficient
sufficiently
suffix
suffixed
suffixer
suffixing
suffixes
suffocate
suffocated
suffocating
suffocation
suffocates
suffrage
sugar
sugared
sugaring
sugarings
sugars
suggest
suggested
suggesting
suggestive
suggests
suggestible
suggestion
suggestion's
suggestions
suggestively
suicidal
suicidally
suicide
suicide's
suicides
suit
suit's
suits
suitability
suitable
suitableness
suitably
suitcase
suitcase's
suitcases
suite
suited
suiters
suiting
suites
suitor
suitor's
suitors
sulk
sulked
sulking
sulks
sulky
sulkiness
sullen
sullenness
sullenly
sulphate
sulphur
sulphured
sulphuric
sultan
sultan's
sultans
sultry
sum
sum's
sums
summand
summand's
summands
summarization
summarization's
summarizations
summarize
summarized
summarizing
summarizes
summary
summary's
summaries
summation
summation's
summations
summed
summer
summer's
summers
summing
summit
summon
summoned
summoner
summoners
summoning
summons
summonses
sumptuous
sun
sun's
suns
sunbeam
sunbeam's
sunbeams
sunburn
sunday
sunday's
sundays
sundown
sundry
sundries
sung
sunglass
sunglasses
sunk
sunken
sunlight
sunned
sunning
sunny
sunrise
sunset
sunshine
sup
super
superb
superbly
supercomputer
supercomputer's
supercomputers
superego
superego's
superegos
superficial
superficially
superfluity
superfluity's
superfluities
superfluous
superfluously
superhuman
superhumanly
superimpose
superimposed
superimposing
superimposes
superintend
superintendent
superintendent's
superintendents
superior
superior's
superiors
superiority
superlative
superlatively
superlatives
supermarket
supermarket's
supermarkets
superpose
superposed
superposing
superposes
superscript
superscripted
superscripting
superscripts
supersede
superseded
superseding
supersedes
superset
superset's
supersets
superstition
superstition's
superstitions
superstitious
supervise
supervised
supervising
supervision
supervises
supervisor
supervisor's
supervisors
supervisory
supper
supper's
suppers
supplant
supplanted
supplanting
supplants
supple
suppleness
supplement
supplemented
supplementing
supplements
supplemental
supplementary
supply
supplied
supplier
suppliers
supplying
supplication
supplies
support
supported
supporter
supporters
supporting
supportive
supports
supportable
supportingly
supportively
suppose
supposed
supposing
supposes
supposedly
supposition
supposition's
suppositions
suppress
suppressed
suppressing
suppressen
suppresses
suppression
supremacy
supreme
supremely
supremity
supremities
sure
sureness
surely
surety
sureties
surf
surface
surfaceness
surfaced
surfacing
surfaces
surge
surged
surging
surges
surgeon
surgeon's
surgeons
surgery
surgical
surgically
surly
surliness
surmise
surmised
surmises
surmount
surmounted
surmounting
surmounts
surname
surname's
surnames
surpass
surpassed
surpassing
surpasses
surplus
surplus's
surpluses
surprise
surprised
surprising
surprises
surprisingly
surrender
surrendered
surrendering
surrenders
surrogate
surrogate's
surrogates
surround
surrounded
surrounding
surroundings
surrounds
survey
surveyed
surveying
surveys
surveyor
surveyor's
surveyors
survival
survivals
survive
survived
surviving
survives
survivor
survivor's
survivors
susceptible
suspect
suspected
suspecting
suspects
suspend
suspended
suspending
suspends
suspender
suspender's
suspenders
suspense
suspension
suspensions
suspenses
suspicion
suspicion's
suspicions
suspicious
suspiciously
sustain
sustained
sustaining
sustains
suture
sutures
swagger
swaggered
swaggering
swain
swain's
swains
swallow
swallowed
swallowing
swallows
swam
swamp
swamped
swamping
swamps
swampy
swan
swan's
swans
swap
swaps
swapped
swapping
swarm
swarmed
swarming
swarms
swarthy
swatted
sway
swayed
swaying
swear
swearer
swearing
swears
sweat
sweated
sweater
sweaters
sweating
sweats
sweep
sweeper
sweepers
sweeping
sweepings
sweeps
sweet
sweetness
sweetest
sweeter
sweetens
sweetly
sweets
sweeten
sweetened
sweetener
sweeteners
sweetening
sweetenings
sweetens
sweetheart
sweetheart's
sweethearts
swell
swelled
swelling
swellings
swells
swept
swerve
swerved
swerving
swerves
swift
swiftness
swiftest
swifter
swiftly
swim
swims
swimmer
swimmer's
swimmers
swimming
swimmingly
swine
swing
swinger
swingers
swinging
swings
swirl
swirled
swirling
swish
swished
switch
switched
switcher
switchers
switching
switchings
switches
switchboard
switchboard's
switchboards
swollen
swoon
swoop
swooped
swooping
swoops
sword
sword's
swords
swore
sworn
swum
swung
sycamore
syllable
syllable's
syllables
syllogism
syllogism's
syllogisms
symbiosis
symbiotic
symbol
symbol's
symbols
symbolic
symbolically
symbolism
symbolization
symbolize
symbolized
symbolizing
symbolizes
symmetric
symmetrical
symmetrically
symmetry
symmetry's
symmetries
sympathetic
sympathize
sympathized
sympathizer
sympathizers
sympathizing
sympathizes
sympathizingly
sympathy
sympathy's
sympathies
symphony
symphony's
symphonies
symposium
symposiums
symptom
symptom's
symptoms
symptomatic
synapse
synapse's
synapses
synchronization
synchronize
synchronized
synchronizer
synchronizers
synchronizing
synchronizes
synchronous
synchronously
synchrony
syndicate
syndicated
syndication
syndicates
syndrome
syndrome's
syndromes
synergism
synergistic
synonym
synonym's
synonyms
synonymous
synonymously
synopses
synopsis
syntactic
syntactical
syntactically
syntax
synthesis
synthesize
synthesized
synthesizer
synthesizers
synthesizing
synthesizes
synthetic
synthetics
syringe
syringes
syrup
system
system's
systems
systematic
systematically
systematize
systematized
systematizing
systematizes
tab
tabs
tabernacle
tabernacle's
tabernacles
table
tabled
tabling
tables
tableau
tableau's
tableaus
tablecloth
tablecloths
tablespoon
tablespoon's
tablespoons
tablespoonful
tablespoonful's
tablespoonfuls
tablet
tablet's
tablets
taboo
taboo's
taboos
tabular
tabulate
tabulated
tabulating
tabulation
tabulations
tabulates
tabulator
tabulator's
tabulators
tachometer
tachometer's
tachometers
tacit
tacitly
tack
tacked
tacking
tackle
tackle's
tackles
tact
tactics
tactile
tag
tag's
tags
tagged
tagging
tail
tailed
tailing
tails
tailor
tailored
tailoring
tailors
taint
tainted
take
taker
takers
taking
takings
takes
taken
tale
tale's
tales
talent
talented
talents
talk
talked
talker
talkers
talking
talks
talkative
talkativeness
talkatively
talkie
tall
tallness
tallest
taller
tallow
tame
tameness
tamed
tamer
taming
tamely
tames
tamper
tampered
tampering
tampers
tan
tandem
tang
tangent
tangent's
tangents
tangential
tangible
tangibly
tangle
tangled
tangy
tank
tanker
tankers
tanks
tanner
tanner's
tanners
tantalizing
tantalizingly
tantamount
tantrum
tantrum's
tantrums
tap
tap's
taps
tape
taped
taper
tapers
taping
tapings
tapes
tapered
tapering
tapestry
tapestry's
tapestries
tapped
tapper
tapper's
tappers
tapping
taproot
taproot's
taproots
tar
tardy
tardiness
target
targeted
targeting
targets
tariff
tariff's
tariffs
tarry
tart
tartness
tartly
task
tasked
tasking
tasks
tassel
tassel's
tassels
taste
tasted
taster
tasters
tasting
tastes
tasteful
tastefulness
tastefully
tasteless
tastelessly
tatter
tattered
tattoo
tattooed
tattoos
tau
taught
taunt
taunted
taunter
taunting
taunts
taut
tautness
tautly
tautological
tautologically
tautology
tautology's
tautologies
tavern
tavern's
taverns
tawny
tax
taxed
taxing
taxes
taxable
taxation
taxi
taxied
taxiing
taxis
taxicab
taxicab's
taxicabs
taxonomic
taxonomically
taxonomy
taxpayer
taxpayer's
taxpayers
tea
teas
teach
teacher
teachers
teaching
teachings
teaches
teachable
teacher's
team
teamed
teaming
teams
tear
teared
tearing
tears
tearful
tearfully
tease
teased
teasing
teases
teaspoon
teaspoon's
teaspoons
teaspoonful
teaspoonful's
teaspoonfuls
technical
technically
technicality
technicality's
technicalities
technician
technician's
technicians
technique
technique's
techniques
technological
technologically
technologist
technologist's
technologists
technology
technologies
tedious
tediousness
tediously
tedium
teem
teemed
teeming
teems
teen
teens
teenage
teenaged
teenager
teenagers
teeth
teethe
teethed
teething
teethes
Teflon
telecommunication
telecommunications
telegram
telegram's
telegrams
telegraph
telegraphed
telegrapher
telegraphers
telegraphing
telegraphic
telegraphs
teleological
teleologically
teleology
telephone
telephoned
telephoner
telephoners
telephoning
telephones
telephonic
telephony
telescope
telescoped
telescoping
telescopes
teletype
teletype's
teletypes
televise
televised
televising
television
televisions
televises
televisor
televisor's
televisors
tell
teller
tellers
telling
tells
temper
tempered
tempering
tempers
temperament
temperaments
temperamental
temperance
temperate
temperateness
temperately
temperature
temperature's
temperatures
tempest
tempestuous
tempestuously
template
template's
templates
temple
temple's
temples
temporal
temporally
temporarily
temporary
temporaries
tempt
tempted
tempter
tempters
tempting
tempts
temptation
temptation's
temptations
temptingly
ten
tenth
tens
tenacious
tenaciously
tenant
tenant's
tenants
tend
tended
tender
tenders
tending
tends
tendency
tendencies
tenderly
tenderness
tenement
tenement's
tenements
tennessee
tennis
tenor
tenor's
tenors
tense
tenseness
tensed
tensest
tenser
tensing
tension
tensions
tensely
tenses
tent
tented
tenting
tents
tentacle
tentacled
tentacles
tentative
tentatively
tenure
term
termed
terming
terms
terminal
terminal's
terminally
terminals
terminate
terminated
terminating
termination
terminations
terminates
terminator
terminator's
terminators
terminology
terminologies
terminus
termwise
ternary
terrace
terraced
terraces
terrain
terrain's
terrains
terrestrial
terrible
terribly
terrier
terrier's
terriers
terrific
terrify
terrified
terrifying
terrifies
territorial
territory
territory's
territories
terror
terror's
terrors
terrorism
terrorist
terrorist's
terrorists
terroristic
terrorize
terrorized
terrorizing
terrorizes
tertiary
test
tested
tester
testers
testing
testings
tests
testability
testable
testament
testament's
testaments
testicle
testicle's
testicles
testify
testified
testifier
testifiers
testifying
testifies
testimony
testimony's
testimonies
texas
text
text's
texts
textbook
textbook's
textbooks
textile
textile's
textiles
textual
textually
texture
textured
textures
than
thank
thanked
thanking
thanks
thankful
thankfulness
thankfully
thankless
thanklessness
thanklessly
thanksgiving
that
that's
thats
thatch
thatches
thaw
thawed
thawing
thaws
the
thing
things
theater
theater's
theaters
theatrical
theatrically
theatricals
theft
theft's
thefts
their
theirs
them
thematic
theme
theme's
themes
themselves
then
thence
thenceforth
theological
theology
theorem
theorem's
theorems
theoretic
theoretical
theoretically
theoreticians
theorist
theorist's
theorists
theorization
theorization's
theorizations
theorize
theorized
theorizer
theorizers
theorizing
theorizes
theory
theory's
theories
therapeutic
therapist
therapist's
therapists
therapy
therapy's
therapies
there
there's
thereabouts
thereafter
thereby
therefore
therein
thereof
thereon
thereto
thereupon
therewith
thermodynamic
thermodynamics
thermometer
thermometer's
thermometers
thermostat
thermostat's
thermostats
these
theses
thesis
they
they'd
they'll
they're
they've
thick
thickness
thickest
thicker
thicken
thickens
thickly
thicket
thicket's
thickets
thief
thieve
thieving
thieves
thigh
thighs
thimble
thimble's
thimbles
thin
thinness
thinly
think
thinker
thinkers
thinking
thinks
thinkable
thinkably
thinner
thinnest
third
thirdly
thirds
thirst
thirsted
thirsts
thirsty
thirteen
thirteenth
thirteens
thirty
thirtieth
thirties
this
thistle
thong
thorn
thorn's
thorns
thorny
thorough
thoroughness
thoroughly
thoroughfare
thoroughfare's
thoroughfares
those
though
thought
thought's
thoughts
thoughtful
thoughtfulness
thoughtfully
thoughtless
thoughtlessness
thoughtlessly
thousand
thousandth
thousands
thrash
thrashed
thrasher
thrashing
thrashes
thread
threaded
threader
threaders
threading
threads
threat
threaten
threats
threaten
threatened
threatening
threatens
three
three's
threes
threescore
threshold
threshold's
thresholds
threw
thrice
thrift
thrifty
thrill
thrilled
thriller
thrillers
thrilling
thrills
thrilling
thrillingly
thrive
thrived
thriving
thrives
throat
throated
throats
throb
throbs
throbbed
throbbing
throne
throne's
thrones
throng
throng's
throngs
throttle
throttled
throttling
throttles
through
throughout
throughput
throw
thrower
throwing
throws
thrown
thrush
thrust
thrusted
thruster
thrusters
thrusting
thrusts
thud
thuds
thug
thug's
thugs
thumb
thumbed
thumbing
thumbs
thump
thumped
thumping
thunder
thundered
thunderer
thunderers
thundering
thunders
thunderbolt
thunderbolt's
thunderbolts
thunderstorm
thunderstorm's
thunderstorms
Thursday
Thursday's
Thursdays
thus
thusly
thwart
thwarted
thwarting
thyself
tick
ticked
ticker
tickers
ticking
ticks
ticket
ticket's
tickets
tickle
tickled
tickling
tickles
tidal
tidally
tide
tided
tiding
tidings
tides
tidy
tidiness
tidied
tidying
tie
tied
tier
tiers
ties
tiger
tiger's
tigers
tight
tightness
tightest
tighter
tightens
tightly
tighten
tightened
tightener
tighteners
tightening
tightenings
tightens
tilde
tile
tiled
tiling
tiles
till
tilled
tiller
tillers
tilling
tills
tillable
tilt
tilted
tilting
tilts
timber
timbered
timbering
timbers
time
timed
timer
timers
timing
timely
timings
times
timesharing
timetable
timetable's
timetables
timid
timidly
timidity
tin
tin's
tins
tinge
tinged
tingle
tingled
tingling
tingles
tinily
tinker
tinkered
tinkering
tinkers
tinkle
tinkled
tinkling
tinkles
tinnily
tinny
tinniness
tinniest
tinnier
tint
tinted
tinting
tints
tiny
tininess
tiniest
tinier
tip
tip's
tips
tipped
tipper
tipper's
tippers
tipping
tiptoe
tire
tired
tiring
tires
tiredly
tireless
tirelessness
tirelessly
tiresome
tiresomeness
tiresomely
tissue
tissue's
tissues
tit
titer
titers
tits
tithe
tither
tithes
title
titled
titles
to
toad
toad's
toads
toast
toasted
toaster
toasting
toasts
tobacco
today
toe
toe's
toes
together
togetherness
toggle
toggled
toggling
toggles
toil
toiled
toiler
toiling
toils
toilet
toilet's
toilets
token
token's
tokens
told
tolerability
tolerable
tolerably
tolerance
tolerances
tolerant
tolerantly
tolerate
tolerated
tolerating
toleration
tolerates
toll
tolled
tolls
tomahawk
tomahawk's
tomahawks
tomato
tomatoes
tomb
tomb's
tombs
tomography
tomorrow
ton
ton's
tons
tone
toned
toner
toning
tones
tongs
tongue
tongued
tongues
tonic
tonic's
tonics
tonight
tonnage
tonsil
too
tooth
took
tool
tooled
tooler
toolers
tooling
tools
toothbrush
toothbrush's
toothbrushes
toothpick
toothpick's
toothpicks
top
toper
tops
topic
topic's
topics
topical
topically
topmost
topological
topology
topologies
topple
toppled
toppling
topples
torch
torch's
torches
tore
torment
tormented
tormenter
tormenters
tormenting
torn
tornado
tornadoes
torpedo
torpedoes
torque
torrent
torrent's
torrents
torrid
tortoise
tortoise's
tortoises
torture
tortured
torturer
torturers
torturing
tortures
torus
torus's
toruses
toss
tossed
tossing
tosses
total
totaled
totaling
totally
totals
totality
totality's
totalities
totalled
totaller
totallers
totalling
totter
tottered
tottering
totters
touch
touched
touching
touches
touchable
touchily
touchingly
touchy
touchiness
touchiest
touchier
tough
toughness
toughest
tougher
toughen
toughly
tour
toured
touring
tours
tourist
tourist's
tourists
tournament
tournament's
tournaments
tow
towed
towers
toward
towards
towel
toweling
towels
towelled
towelling
tower
towered
towering
towers
town
town's
towns
township
township's
townships
toy
toyed
toying
toys
trace
traced
tracer
tracers
tracing
tracings
traces
traceable
track
tracked
tracker
trackers
tracking
tracks
tract
tract's
tractive
tracts
tractability
tractable
tractor
tractor's
tractors
trade
traded
trader
traders
trading
trades
trademark
trademark's
trademarks
tradesman
tradition
tradition's
traditions
traditional
traditionally
traffic
traffic's
traffics
trafficked
trafficker
trafficker's
traffickers
trafficking
tragedy
tragedy's
tragedies
tragic
tragically
trail
trailed
trailer
trailers
trailing
trailings
trails
train
trained
trainer
trainers
training
trains
trainee
trainee's
trainees
trait
trait's
traits
traitor
traitor's
traitors
trajectory
trajectory's
trajectories
tramp
tramped
tramping
tramps
trample
trampled
trampler
trampling
tramples
trance
trance's
trances
tranquil
tranquilly
tranquility
transact
transaction
transaction's
transactions
transcend
transcended
transcending
transcends
transcendent
transcontinental
transcribe
transcribed
transcriber
transcribers
transcribing
transcribes
transcript
transcript's
transcripts
transcription
transcription's
transcriptions
transfer
transfer's
transfers
transferable
transferal
transferal's
transferals
transferred
transferrer
transferrer's
transferrers
transferring
transfinite
transform
transformed
transformer
transformers
transforming
transforms
transformable
transformation
transformation's
transformations
transformational
transgress
transgressed
transgression
transgression's
transgressions
transient
transiently
transients
transistor
transistor's
transistors
transit
transition
transitioned
transitions
transitional
transitive
transitiveness
transitively
transitivity
transitory
translatability
translatable
translate
translated
translating
translation
translations
translates
translational
translator
translator's
translators
translucent
transmission
transmission's
transmissions
transmit
transmits
transmittal
transmitted
transmitter
transmitter's
transmitters
transmitting
transmogrify
transmogrification
transparency
transparency's
transparencies
transparent
transparently
transpire
transpired
transpiring
transpires
transplant
transplanted
transplanting
transplants
transport
transported
transporter
transporters
transporting
transports
transportability
transportation
transpose
transposed
transposing
transposes
transposition
trap
trap's
traps
trapezoid
trapezoid's
trapezoids
trapezoidal
trapped
trapper
trapper's
trappers
trapping
trappings
trash
traumatic
travail
travel
traveled
traveler
travelers
traveling
travelings
travels
traversal
traversal's
traversals
traverse
traversed
traversing
traverses
travesty
travesty's
travesties
tray
tray's
trays
treacherous
treacherously
treachery
treachery's
treacheries
tread
treading
treads
treason
treasure
treasured
treasurer
treasuring
treasures
treasury
treasury's
treasuries
treat
treated
treating
treats
treatise
treatise's
treatises
treatment
treatment's
treatments
treaty
treaty's
treaties
treble
tree
tree's
trees
treetop
treetop's
treetops
trek
trek's
treks
tremble
trembled
trembling
trembles
tremendous
tremendously
tremor
tremor's
tremors
trench
trencher
trenches
trend
trending
trends
trespass
trespassed
trespasser
trespassers
trespasses
tress
tress's
tresses
trial
trial's
trials
triangle
triangle's
triangles
triangular
triangularly
tribal
tribe
tribe's
tribes
tribunal
tribunal's
tribunals
tribune
tribune's
tribunes
tributary
tribute
tribute's
tributes
trichotomy
trick
tricked
tricking
tricks
trickle
trickled
trickling
trickles
tricky
trickiness
trickiest
trickier
trifle
trifler
trifling
trifles
trigger
triggered
triggering
triggers
trigonometric
trigonometry
trihedral
trill
trilled
trillion
trillionth
trillions
trim
trimness
trimly
trims
trimmed
trimmer
trimmest
trimming
trimmings
trinket
trinket's
trinkets
trip
trip's
trips
triple
tripled
tripling
triples
triplet
triplet's
triplets
triumph
triumphed
triumphing
triumphal
triumphantly
triumphs
trivia
trivial
trivially
triviality
trivialities
trod
troll
troll's
trolls
trolley
trolley's
trolleys
troop
trooper
troopers
troops
trophy
trophy's
trophies
tropic
tropic's
tropics
tropical
trot
trots
trouble
troubled
troubling
troubles
troublemaker
troublemaker's
troublemakers
troubleshoot
troubleshooter
troubleshooters
troubleshooting
troubleshoots
troublesome
troublesomely
trough
trouser
trousers
trout
trowel
trowel's
trowels
truant
truant's
truants
truce
truck
trucked
trucker
truckers
trucking
trucks
trudge
trudged
true
trued
truest
truer
truing
trues
truism
truism's
truisms
truly
trump
trumped
trumps
trumpet
trumpeter
truncate
truncated
truncating
truncates
truncation
truncation's
truncations
trunk
trunk's
trunks
trust
trusted
trusting
trusts
trustee
trustee's
trustees
trustful
trustfulness
trustfully
trustingly
trustworthy
trustworthiness
trusty
truth
truthful
truthfulness
truthfully
truths
try
tried
trier
triers
trying
tries
tub
tub's
tubs
tube
tuber
tubers
tubing
tubes
tuberculosis
tuck
tucked
tucker
tucking
tucks
Tuesday
Tuesday's
Tuesdays
tuft
tuft's
tufts
tug
tugs
tuition
tulip
tulip's
tulips
tumble
tumbled
tumbler
tumblers
tumbling
tumbles
tumor
tumors
tumult
tumult's
tumults
tumultuous
tunable
tune
tuned
tuner
tuners
tuning
tunes
tunic
tunic's
tunics
tunnel
tunneled
tunnels
tuple
tuple's
tuples
turban
turban's
turbans
turbulent
turbulently
turf
turing
turkey
turkey's
turkeys
turmoil
turmoil's
turmoils
turn
turned
turner
turners
turning
turnings
turns
turnable
turnip
turnip's
turnips
turnover
turpentine
turquoise
turret
turret's
turrets
turtle
turtle's
turtles
tutor
tutored
tutoring
tutors
tutorial
tutorial's
tutorials
twain
twang
twas
tweed
twelfth
twelve
twelves
twenty
twentieth
twenties
twice
twig
twig's
twigs
twilight
twilight's
twilights
twill
twin
twin's
twins
twine
twined
twiner
twinkle
twinkled
twinkler
twinkling
twinkles
twirl
twirled
twirler
twirling
twirls
twist
twisted
twister
twisters
twisting
twists
twitch
twitched
twitching
twitter
twittered
twittering
two
two's
twos
twofold
tying
type
typed
type's
typing
types
typeout
typewriter
typewriter's
typewriters
typhoid
typical
typicalness
typically
typify
typified
typifying
typifies
typist
typist's
typists
typographical
typographically
tyranny
tyrant
tyrant's
tyrants
ubiquitous
ubiquitously
ubiquity
ugh
ugly
ugliness
ugliest
uglier
ulcer
ulcer's
ulcers
ultimate
ultimately
umbrella
umbrella's
umbrellas
umpire
umpire's
umpires
unabated
unabbreviated
unable
unacceptability
unacceptable
unacceptably
unaccustomed
unacknowledged
unadulterated
unaesthetically
unaffected
unaffectedness
unaffectedly
unaided
unalienability
unalienable
unalterably
unaltered
unambiguous
unambiguously
unambitious
unanalyzable
unanimous
unanimously
unanswered
unanticipated
unarmed
unary
unassailable
unassigned
unattainability
unattainable
unattended
unattractive
unattractively
unauthorized
unavailability
unavailable
unavoidable
unavoidably
unaware
unawareness
unawares
unbalanced
unbearable
unbelievable
unbiased
unblock
unblocked
unblocking
unblocks
unborn
unbound
unbounded
unbreakable
unbroken
unbuffered
uncancelled
uncanny
uncapitalized
uncaught
uncertain
uncertainly
uncertainty
uncertainties
unchangeable
unchanged
unchanging
unclaimed
uncle
uncle's
uncles
unclean
uncleanness
uncleanly
unclear
uncleared
unclosed
uncomfortable
uncomfortably
uncommitted
uncommon
uncommonly
uncompromising
uncomputable
unconcerned
unconcernedly
unconditional
unconditionally
unconnected
unconscious
unconsciousness
unconsciously
unconstrained
uncontrollability
uncontrollable
uncontrollably
uncontrolled
unconventional
unconventionally
unconvinced
unconvincing
uncorrectable
uncorrected
uncountable
uncountably
uncouth
uncover
uncovered
uncovering
uncovers
undaunted
undauntedly
undecidable
undecided
undeclared
undecomposable
undefinability
undefined
undeleted
undeniably
under
underbrush
underdone
underestimate
underestimated
underestimating
underestimation
underestimates
underflow
underflowed
underflowing
underflows
underfoot
undergo
undergoing
undergos
undergoes
undergone
undergraduate
undergraduate's
undergraduates
underground
underlie
underlies
underline
underlined
underlining
underlinings
underlines
underling
underling's
underlings
underlying
undermine
undermined
undermining
undermines
underneath
underpinning
underpinnings
underplay
underplayed
underplaying
underplays
underscore
underscored
underscores
understand
understanding
understandings
understands
understandability
understandable
understandably
understandingly
understated
understood
undertake
undertaker
undertakers
undertaking
undertakings
undertakes
undertaken
undertook
underway
underwear
underwent
underworld
underwrite
underwriter
underwriters
underwriting
underwrites
undesirability
undesirable
undetectable
undetected
undetermined
undeveloped
undid
undirected
undisciplined
undiscovered
undisturbed
undivided
undo
undoing
undoings
undocumented
undoes
undone
undoubtedly
undress
undressed
undressing
undresses
undue
unduly
uneasily
uneasy
uneasiness
uneconomical
unembellished
unemployed
unemployment
unending
unenlightening
unequal
unequaled
unequally
unequivocal
unequivocally
unessential
unevaluated
uneven
unevenness
unevenly
uneventful
unexcused
unexpanded
unexpected
unexpectedly
unexplained
unexplored
unextended
unfair
unfairness
unfairly
unfaithful
unfaithfulness
unfaithfully
unfamiliar
unfamiliarly
unfamiliarity
unfavorable
unfettered
unfinished
unfit
unfitness
unflagging
unfold
unfolded
unfolding
unfolds
unforeseen
unforgeable
unforgiving
unformatted
unfortunate
unfortunately
unfortunates
unfounded
unfriendly
unfriendliness
unfulfilled
ungrammatical
ungrateful
ungratefulness
ungratefully
ungrounded
unguarded
unguided
unhappily
unhappy
unhappiness
unhappiest
unhappier
unhealthy
unheeded
unicorn
unicorn's
unicorns
unidentified
unidirectional
unidirectionally
unidirectionality
uniform
uniformed
uniformly
uniforms
uniformity
unify
unified
unifier
unifiers
unifying
unification
unifications
unifies
unilluminating
unimaginable
unimpeded
unimplemented
unimportant
unindented
uninitialized
unintelligible
unintended
unintentional
unintentionally
uninteresting
uninterestingly
uninterpreted
uninterrupted
uninterruptedly
union
union's
unions
unionization
unionize
unionized
unionizer
unionizers
unionizing
unionizes
unique
uniqueness
uniquely
unison
unit
unit's
units
unite
united
uniting
unites
unity
unity's
unities
univalve
univalve's
univalves
universal
universally
universals
universality
universe
universe's
universes
university
university's
universities
unjust
unjustly
unjustified
unkind
unkindness
unkindly
unknowable
unknowing
unknowingly
unknown
unknowns
unlabeled
unlawful
unlawfully
unleash
unleashed
unleashing
unleashes
unless
unlike
unlikeness
unlikely
unlimited
unlink
unlinked
unlinking
unlinks
unload
unloaded
unloading
unloads
unlock
unlocked
unlocking
unlocks
unlucky
unmanageable
unmanageably
unmanned
unmarked
unmarried
unmasked
unmatched
unmistakable
unmodified
unmoved
unnamed
unnatural
unnaturalness
unnaturally
unnecessarily
unnecessary
unneeded
unnoticed
unobservable
unobserved
unobtainable
unoccupied
unofficial
unofficially
unopened
unordered
unpack
unpacked
unpacking
unpacks
unparalleled
unparsed
unplanned
unpleasant
unpleasantness
unpleasantly
unpopular
unpopularity
unprecedented
unpredictable
unprescribed
unpreserved
unprimed
unprofitable
unprojected
unprotected
unprovability
unprovable
unproven
unpublished
unqualified
unqualifiedly
unquestionably
unquestioned
unquoted
unravel
unraveled
unraveling
unravels
unreachable
unreal
unrealistic
unrealistically
unreasonable
unreasonableness
unreasonably
unrecognizable
unrecognized
unrelated
unreliability
unreliable
unreported
unrepresentable
unresolved
unresponsive
unrest
unrestrained
unrestricted
unrestrictedly
unrestrictive
unroll
unrolled
unrolling
unrolls
unruly
unsafe
unsafely
unsanitary
unsatisfactory
unsatisfiability
unsatisfiable
unsatisfied
unsatisfying
unscrupulous
unseeded
unseen
unselected
unselfish
unselfishness
unselfishly
unsent
unsettled
unsettling
unshaken
unshared
unsigned
unskilled
unsolvable
unsolved
unsophisticated
unsound
unspeakable
unspecified
unstable
unsteady
unsteadiness
unstructured
unsuccessful
unsuccessfully
unsuitable
unsuited
unsupported
unsure
unsurprising
unsurprisingly
unsynchronized
untapped
unterminated
untested
unthinkable
untidy
untidiness
untie
untied
unties
until
untimely
unto
untold
untouchable
untouchable's
untouchables
untouched
untoward
untrained
untranslated
untreated
untried
untrue
untruthful
untruthfulness
untying
unusable
unused
unusual
unusually
unvarying
unveil
unveiled
unveiling
unveils
unwanted
unwelcome
unwholesome
unwieldy
unwieldiness
unwilling
unwillingness
unwillingly
unwind
unwinder
unwinders
unwinding
unwinds
unwise
unwisely
unwitting
unwittingly
unworthy
unworthiness
unwound
unwritten
up
upbraid
update
updated
updater
updating
updates
upgrade
upgraded
upgrading
upgrades
upheld
uphill
uphold
upholder
upholders
upholding
upholds
upholster
upholstered
upholsterer
upholstering
upholsters
upkeep
upland
uplands
uplift
upon
upper
uppermost
upright
uprightness
uprightly
uprising
uprising's
uprisings
uproar
uproot
uprooted
uprooting
uproots
upset
upsets
upshot
upshot's
upshots
upside
upstairs
upstream
upturn
upturned
upturning
upturns
upward
upwards
urban
urchin
urchin's
urchins
urge
urged
urging
urgings
urges
urgent
urgently
urinate
urinated
urinating
urination
urinates
urine
urn
urn's
urns
us
usability
usable
usably
usage
usages
use
used
user
users
using
uses
useful
usefulness
usefully
useless
uselessness
uselessly
user's
usher
ushered
ushering
ushers
usual
usually
usurp
usurped
usurper
utah
utensil
utensil's
utensils
utility
utility's
utilities
utilization
utilization's
utilizations
utilize
utilized
utilizing
utilizes
utmost
utopian
utopian's
utopians
utter
uttered
uttering
utterly
utters
utterance
utterance's
utterances
uttermost
vacancy
vacancy's
vacancies
vacant
vacantly
vacate
vacated
vacating
vacations
vacates
vacation
vacationed
vacationer
vacationers
vacationing
vacations
vacuo
vacuous
vacuously
vacuum
vacuumed
vacuuming
vagabond
vagabond's
vagabonds
vagary
vagary's
vagaries
vagina
vagina's
vaginas
vagrant
vagrantly
vague
vagueness
vaguest
vaguer
vaguely
vainly
vale
vale's
vales
valence
valence's
valences
valentine
valentine's
valentines
valet
valet's
valets
valiant
valiantly
valid
validness
validly
validate
validated
validating
validation
validates
validity
valley
valley's
valleys
valor
valuable
valuables
valuably
valuation
valuation's
valuations
value
valued
valuer
valuers
valuing
values
valve
valve's
valves
van
van's
vans
vandalize
vandalized
vandalizing
vandalizes
vane
vane's
vanes
vanilla
vanish
vanished
vanisher
vanishing
vanishes
vanishingly
vanity
vanities
vanquish
vanquished
vanquishing
vanquishes
vantage
vapor
vaporing
vapors
variability
variable
variableness
variable's
variables
variably
variance
variance's
variances
variant
variantly
variants
variation
variation's
variations
variety
variety's
varieties
various
variously
varnish
varnish's
varnishes
vary
varied
varying
varyings
varies
vase
vase's
vases
vassal
vast
vastness
vastest
vaster
vastly
vat
vat's
vats
vaudeville
vault
vaulted
vaulter
vaulting
vaults
vaunt
vaunted
veal
vector
vector's
vectors
vectorization
vectorizing
veer
veered
veering
veers
vegetable
vegetable's
vegetables
vegetarian
vegetarian's
vegetarians
vegetate
vegetated
vegetating
vegetation
vegetative
vegetates
vehemence
vehement
vehemently
vehicle
vehicle's
vehicles
vehicular
veil
veiled
veiling
veils
vein
veined
veining
veins
velocity
velocity's
velocities
velvet
vendor
vendor's
vendors
venerable
vengeance
venison
venom
venomous
venomously
vent
vented
vents
ventilate
ventilated
ventilating
ventilation
ventilates
ventricle
ventricle's
ventricles
venture
ventured
venturer
venturers
venturing
venturings
ventures
veracity
veranda
veranda's
verandas
verb
verb's
verbs
verbal
verbally
verbose
verdict
verdure
verge
verger
verges
verifiability
verifiable
verify
verified
verifier
verifiers
verifying
verification
verifications
verifies
verily
veritable
vermin
versa
versatile
versatility
verse
versed
versing
version
versions
verses
versus
vertebrate
vertebrate's
vertebrates
vertex
vertical
verticalness
vertically
vertices
very
vessel
vessel's
vessels
vest
vested
vests
vestige
vestige's
vestiges
vestigial
veteran
veteran's
veterans
veterinarian
veterinarian's
veterinarians
veterinary
veto
vetoed
vetoer
vetoes
vex
vexed
vexing
vexes
vexation
via
viability
viable
viably
vial
vial's
vials
vibrate
vibrated
vibrating
vibration
vibrations
vice
vice's
vices
viceroy
vicinity
vicious
viciousness
viciously
vicissitude
vicissitude's
vicissitudes
victim
victim's
victims
victimize
victimized
victimizer
victimizers
victimizing
victimizes
victor
victor's
victors
victorious
victoriously
victory
victory's
victories
victual
victualer
victuals
video
videotape
videotape's
videotapes
vie
vied
vier
vies
view
viewed
viewer
viewers
viewing
views
viewable
viewpoint
viewpoint's
viewpoints
vigilance
vigilant
vigilantly
vigilante
vigilante's
vigilantes
vignette
vignette's
vignettes
vigor
vigorous
vigorously
vile
vileness
vilely
vilify
vilified
vilifying
vilification
vilifications
vilifies
villa
villa's
villas
village
villager
villagers
villages
villain
villain's
villains
villainous
villainousness
villainously
villainy
vindictive
vindictiveness
vindictively
vine
vine's
vines
vinegar
vineyard
vineyard's
vineyards
vintage
violate
violated
violating
violation
violations
violates
violator
violator's
violators
violence
violent
violently
violet
violet's
violets
violin
violin's
violins
violinist
violinist's
violinists
viper
viper's
vipers
virgin
virgin's
virgins
Virginia
virginity
virtual
virtually
virtue
virtue's
virtues
virtuoso
virtuoso's
virtuosos
virtuous
virtuously
virus
virus's
viruses
visa
visas
visage
viscount
viscount's
viscounts
viscous
visibility
visible
visibly
vision
vision's
visions
visionary
visit
visited
visiting
visits
visitation
visitation's
visitations
visitor
visitor's
visitors
visor
visor's
visors
vista
vista's
vistas
visual
visually
visualize
visualized
visualizer
visualizing
visualizes
vita
vitae
vital
vitally
vitals
vitality
vivid
vividness
vividly
vizier
vocabulary
vocabularies
vocal
vocally
vocals
vocation
vocation's
vocations
vocational
vocationally
vogue
voice
voiced
voicer
voicers
voicing
voices
void
voided
voider
voiding
voids
volatile
volatility
volatilities
volcanic
volcano
volcano's
volcanos
volley
volleyball
volleyball's
volleyballs
volt
volts
voltage
voltages
volume
volume's
volumes
voluntarily
voluntary
volunteer
volunteered
volunteering
volunteers
vomit
vomited
vomiting
vomits
vote
voted
voter
voters
voting
votive
votes
vouch
voucher
vouchers
vouching
vouches
vow
vowed
vower
vowing
vows
vowel
vowel's
vowels
voyage
voyaged
voyager
voyagers
voyaging
voyagings
voyages
vulgar
vulgarly
vulnerability
vulnerabilities
vulnerable
vulture
vulture's
vultures
wade
waded
wader
wading
wades
wafer
wafer's
wafers
waffle
waffle's
waffles
waft
wag
wags
wage
waged
wager
wagers
waging
wages
wagon
wagoner
wagons
wail
wailed
wailing
wails
waist
waist's
waists
waistcoat
waistcoat's
waistcoats
wait
waited
waiter
waiters
waiting
waits
waitress
waitress's
waitresses
waive
waived
waiver
waiving
waives
waiverable
wake
waked
waking
wakes
waken
wakened
wakening
walk
walked
walker
walkers
walking
walks
wall
walled
walling
walls
wallet
wallet's
wallets
wallow
wallowed
wallowing
wallows
walnut
walnut's
walnuts
walrus
walrus's
walruses
waltz
waltzed
waltzing
waltzes
wan
wanly
wand
wanders
wander
wandered
wanderer
wanderers
wandering
wanderings
wanders
wane
waned
waning
wanes
want
wanted
wanting
wants
wanton
wantonness
wantonly
war
war's
wars
warble
warbled
warbler
warbling
warbles
ward
warder
warden
wardens
wards
wardrobe
wardrobe's
wardrobes
ware
wares
warehouse
warehousing
warehouses
warfare
warily
warlike
warm
warmed
warmest
warming
warmth
warmly
warms
warmer
warmers
warn
warned
warner
warning
warnings
warns
warningly
warp
warped
warping
warps
warrant
warranted
warranting
warrants
warranty
warranty's
warranties
warred
warring
warrior
warrior's
warriors
warship
warship's
warships
wart
wart's
warts
wary
wariness
was
wash
washed
washer
washers
washing
washings
washes
Washington
wasn't
wasp
wasp's
wasps
waste
wasted
wasting
wastes
wasteful
wastefulness
wastefully
watch
watched
watcher
watchers
watching
watchings
watches
watchful
watchfulness
watchfully
watchman
watchword
watchword's
watchwords
water
watered
watering
waterings
waters
waterfall
waterfall's
waterfalls
waterproof
waterproofing
waterway
waterway's
waterways
watery
wave
waved
waver
wavers
waving
waves
waveform
waveform's
waveforms
wavefront
wavefront's
wavefronts
wavelength
wavelengths
wax
waxed
waxer
waxers
waxing
waxen
waxes
waxy
way
way's
ways
wayside
wayward
we
west
we'd
we'll
we're
we've
weak
weakest
weaker
weaken
weakens
weakly
weaken
weakened
weakening
weakens
weakness
weakness's
weaknesses
wealth
wealths
wealthy
wealthiest
wean
weaned
weaning
weapon
weapon's
weapons
wear
wearer
wearing
wears
wearable
wearily
wearisome
wearisomely
weary
weariness
wearied
weariest
wearier
wearying
weasel
weasel's
weasels
weather
weathered
weathering
weathers
weathercock
weathercock's
weathercocks
weave
weaver
weaving
weaves
web
web's
webs
wed
weds
wedded
wedding
wedding's
weddings
wedge
wedged
wedging
wedges
Wednesday
Wednesday's
Wednesdays
wee
weed
weeds
week
weekly
weeks
weekend
weekend's
weekends
weep
weeped
weeper
weeping
weeps
weigh
weighed
weighing
weighings
weighs
weight
weighted
weighting
weights
weird
weirdly
welcome
welcomed
welcoming
welcomes
weld
welded
welder
welding
welds
welfare
well
welled
welling
wells
wench
wench's
wenches
went
wept
were
weren't
western
westerner
westerners
westward
westwards
wet
wetness
wetly
wets
wetted
wetter
wettest
wetting
whack
whacked
whacking
whacks
whale
whaler
whaling
whales
wharf
wharves
what
what's
whatever
whatsoever
wheat
wheaten
wheel
wheeled
wheeler
wheelers
wheeling
wheelings
wheels
whelp
when
whence
whenever
where
where's
whereabouts
whereas
whereby
wherein
whereupon
wherever
whether
which
whichever
while
whim
whim's
whims
whimper
whimpered
whimpering
whimpers
whimsical
whimsically
whimsy
whimsy's
whimsies
whine
whined
whining
whines
whip
whip's
whips
whipped
whipper
whipper's
whippers
whipping
whipping's
whippings
whirl
whirled
whirling
whirls
whirlpool
whirlpool's
whirlpools
whirlwind
whirr
whirring
whisk
whisked
whisker
whiskers
whisking
whisks
whiskey
whisper
whispered
whispering
whisperings
whispers
whistle
whistled
whistler
whistlers
whistling
whistles
whit
whitens
white
whiteness
whitest
whiter
whiting
whitely
whites
whiten
whitened
whitener
whiteners
whitening
whitens
whitespace
whitewash
whitewashed
whittle
whittled
whittling
whittles
whiz
whizzed
whizzes
whizzing
who
who's
whoever
whole
wholeness
wholes
wholehearted
wholeheartedly
wholesale
wholesaler
wholesalers
wholesome
wholesomeness
wholly
whom
whomever
whoop
whooped
whooping
whoops
whore
whore's
whores
whorl
whorl's
whorls
whose
why
wick
wicked
wicker
wicks
wicked
wickedness
wickedly
wide
widest
wider
widely
widen
widened
widener
widening
widens
widespread
widow
widowed
widower
widowers
widows
width
widths
wield
wielded
wielder
wielding
wields
wife
wife's
wifely
wig
wig's
wigs
wigwam
wild
wildness
wildest
wilder
wildly
wildcat
wildcat's
wildcats
wilderness
wile
wiles
will
willed
willing
wills
willful
willfully
willingly
willingness
willow
willow's
willows
wilt
wilted
wilting
wilts
wily
wiliness
win
wins
wince
winced
wincing
winces
wind
winded
winder
winders
winding
winds
windmill
windmill's
windmills
window
window's
windows
windy
wine
wined
winer
winers
wining
wines
wing
winged
winging
wings
wink
winked
winker
winking
winks
winner
winner's
winners
winning
winningly
winnings
winter
wintered
wintering
winters
wintry
wipe
wiped
wiper
wipers
wiping
wipes
wire
wired
wiring
wires
wireless
wiretap
wiretap's
wiretaps
wiry
wiriness
wisdom
wisdoms
wise
wised
wisest
wiser
wisely
wish
wished
wisher
wishers
wishing
wishes
wishful
wisp
wisp's
wisps
wistful
wistfulness
wistfully
wit
wit's
wits
witch
witching
witches
witchcraft
with
wither
withers
withal
withdraw
withdrawing
withdraws
withdrawal
withdrawal's
withdrawals
withdrawn
withdrew
withheld
withhold
withholder
withholders
withholding
withholdings
withholds
within
without
withstand
withstanding
withstands
withstood
witness
witnessed
witnessing
witnesses
witty
wives
wizard
wizard's
wizards
woe
woeful
woefully
woke
wolf
wolves
woman
woman's
womanly
womanhood
womb
womb's
wombs
women
women's
won
won't
wonder
wondered
wondering
wonders
wonderful
wonderfulness
wonderfully
wonderingly
wonderment
wondrous
wondrously
wont
wonted
woo
wooed
wooer
wooing
woos
wood
wooded
wooden
woods
woodchuck
woodchuck's
woodchucks
woodcock
woodcock's
woodcocks
woodenly
woodenness
woodland
woodman
woodpecker
woodpecker's
woodpeckers
woodwork
woodworking
woody
woof
woofed
woofer
woofers
woofing
woofs
wool
woolen
woolly
wools
word
worded
word's
wording
words
wordily
wordy
wordiness
wore
work
worked
worker
workers
working
workings
works
workable
workably
workbench
workbench's
workbenches
workbook
workbook's
workbooks
workhorse
workhorse's
workhorses
workingman
workload
workman
workmanship
workmen
workshop
workshop's
workshops
world
world's
worldly
worlds
worldliness
worldwide
worm
wormed
worming
worms
worn
worrisome
worry
worried
worrier
worriers
worrying
worries
worryingly
worse
worship
worshiped
worshiper
worshiping
worships
worshipful
worst
worsted
worth
worthless
worthlessness
worths
worthwhile
worthwhileness
worthy
worthiness
worthiest
would
wouldn't
wound
wounded
wounding
wounds
wove
woven
wrangle
wrangled
wrangler
wrap
wrap's
wraps
wrapped
wrapper
wrapper's
wrappers
wrapping
wrappings
wrath
wreak
wreaks
wreath
wreathed
wreathes
wreck
wrecked
wrecker
wreckers
wrecking
wrecks
wreckage
wren
wren's
wrens
wrench
wrenched
wrenching
wrenches
wrest
wrestle
wrestler
wrestling
wrestlings
wrestles
wretch
wretched
wretches
wretchedness
wriggle
wriggled
wriggler
wriggling
wriggles
wring
wringer
wrings
wrinkle
wrinkled
wrinkles
wrist
wrist's
wrists
wristwatch
wristwatch's
wristwatches
writ
writ's
writs
writable
write
writer
writers
writing
writings
writes
writer's
writhe
writhed
writhing
writhes
written
wrong
wronged
wronging
wrongly
wrongs
wrote
wrought
wrung
yank
yanked
yanking
yanks
yard
yard's
yards
yardstick
yardstick's
yardsticks
yarn
yarn's
yarns
yawn
yawner
yawning
yea
yeas
year
year's
yearly
years
yearn
yearned
yearning
yearnings
yeast
yeast's
yeasts
yell
yelled
yeller
yelling
yellow
yellowness
yellowed
yellowest
yellower
yellowing
yellows
yellowish
yelp
yelped
yelping
yelps
yeoman
yeomen
yes
yesterday
yet
yield
yielded
yielding
yields
yoke
yoke's
yokes
yon
yonder
york
Yorker
Yorkers
you
youth
you'd
you'll
you're
you've
young
youngest
younger
youngly
youngster
youngster's
youngsters
your
yours
yourself
yourselves
youthful
youthfulness
youthfully
youths
zeal
zealous
zealousness
zealously
zebra
zebra's
zebras
zenith
zero
zeroed
zeroing
zeroth
zeros
zeroes
zest
zigzag
zinc
Zodiac
zonal
zonally
zone
zoned
zoning
zones
zoo
zoo's
zoos
zoological
zoologically
::::::::::
SPELLER_ACRONYM.DCT
::::::::::
AACS
AAL
AAME
AAPL
AAU
ABC
ABE
ABEND
ABP
AC
ACAM
ACC
ACCAP
ACCESS
ACD
ACE
ACES
ACF
ACG
ACIA
ACID
ACK
ACL
ACM
ACMAC
ACMSC
ACO
ACOPP
ACORN
ACOS
ACP
ACPA
ACR
ACS
ACSYS
ACT
ACTRAN
ACTS
ACTSU
ACU
AD
Ada
ADABAS
ADAC
ADAM
ADAPS
ADAPSO
ADAS
ADAT
ADBS
ADCC
ADCCP
ADCVR
ADD
ADDAR
ADDS
ADE
ADEPT
ADF
ADIOS
ADL
ADLC
ADLIB
ADM
ADMIRE
ADMIS
ADO
ADONIS
ADOS
ADP
ADPCM
ADPE
ADPP
ADPS
ADR
ADRAC
ADRS
ADRT
ADS
ADSTAR
ADSUP
ADT
ADTS
ADU
ADX
AE
AEA
AEC
AEG
AEI
AEL
AEON
AEPS
AEROSAT
AF
AFC
AFF
AFG
AFO
AFT
AFTN
AGC
AGLINET
AGNES
AGT
AH
AI
AIAA
AIB
AICA
AID
AIDA
AIDC
AIDE
AIDI
AIDS
AIET
AIKR
AIL
AIM
AIMC
AIMS
AIO
AIOP
AIP
AIT
AJ
AL
ALAP
ALC
ALCAPP
ALCOM
ALCU
ALD
ALERT
ALF
ALFTRAN
ALGO
ALGOL
ALI
ALM
ALMS
ALP
ALPS
ALS
ALTRAN
ALU
AM
AMA
AMC
AMD
AME
AML
AMM
AMOS
AMP
AMPL
AMPS
AMR
AMU
ANA
ANACOM
ANATRAN
ANLES
ANS
ANSA
ANSCR
ANSI
ANTS
AOC
AOCU
AOD
AOF
AOI
AOL
AOS
AOSI
AOU
AP
APAL
APAM
APAR
APC
APCS
APG
API
APK
APL
APM
APP
APPECS
APPLE
APR
APS
APSE
APSK
APSP
APSS
APT
APU
AQL
AR
ARC
ARCS
ARD
ARF
ARL
ARM
ARO
AROM
AROS
ARPA
ARPANET
ARQ
ARR
ARS
ARSC
ART
ARU
AS
ASA
ASC
ASCENT
ASCII
ASCP
ASCU
ASCUE
ASES
ASF
ASI
ASID
ASK
ASL
ASLT
ASM
ASP
ASPER
ASPI
ASR
ASS
ASSIRIS
AST
ASU
ASV
ASVIP
ASVS
AT
ATT
ATB
ATDM
ATE
ATF
ATLAS
ATM
ATOM
ATR
ATS
ATSS
ATSU
ATU
AU
AUI
AUNT
AUTODIN
AUTOMAP
AUTOMEX
AUTOPIC
AUTOPROMPT
AUTOPSY
AUTOSDI
AUTOSEVOCOM
AUTOVON
AV
AVA
AVC
AVD
AVG
AVP
AVR
AWC
AZ
BA
BACE
BAL
BALGOL
BAM
BAP
BAR
BASIS
BASYS
BATS
BB
BBC
BBL
BBS
BC
BCC
BCD
BCDC
BCDIC
BCI
BCH
BCL
BCO
BCP
BCPL
BCPS
BCR
BCS
BCT
BCU
BCW
BD
BDAM
BDC
BDCB
BDD
BDDT
BDIC
BDLC
BDN
BDOS
BDR
BDS
BDTS
BDU
BECS
BED
BEL
BELLTIP
BER
BERM
BERT
BES
BEU
BF
BFAS
BFD
BFL
BFO
BGRAF
BH
BI
BIAS
BIC
BICEPT
BID
BIDAP
BIDS
BIF
BIL
BIM
BIO
BIONIC
BIOP
BIOR
BIOS
BIP
BIPA
BIPS
BIRS
BIS
BISAM
BISNY
BISYNC
BIT
bit
BIU
BIX
BJF
BJM
BL
BLA
BLAISE
BLERT
BLIS
BLISS
BLLD
BLM
BLO
BLOC
BLT
BLU
BM
BMC
BMD
BMG
BMI
BMMC
BMTI
BMTT
BN
BNC
BNF
BNPF
BO
BOC
BOCOL
BOFA
BOI
BOLD
BOM
BOP
BOR
BORAM
BORIS
BOS
BOSS
BOT
BP
BPA
BPAM
BPC
BPCC
BPDA
BPF
BPI
BPIF
BPL
BPM
BPMM
BPS
BPSI
BPSK
BQL
BRD
BRG
BRM
BROM
BROWSER
BRS
BRT
BS
BSAL
BSAM
BSC
BSCA
BSCFL
BSCM
BSC
BSD
BSDC
BSDP
BSE
BSL
BSM
BSP
BSR
BSS
BST
BT
BTAM
BTC
BTD
BTE
BTF
BTG
BTI
BTL
BTM
BTMF
BTP
BTRL
BTS
BTSS
BTU
BTX
BU
BUMP
BUR
BWC
BX
BXB
BYMUX
BYSINC
BW
BWT
BYP
BZ
CAAS
CAAT
CAB
CABS
CAC
CACD
CACM
CACS
CAD
CADA
CADAR
CADC
CADD
CADE
CADEP
CADES
CADIC
CADIG
CADIS
CADMAT
CADS
CADSS
CAE
CAF
CAFS
CAG
CAGE
CAI
CAIC
CAIP
CAIS
CAK
CAL
CALCOMP
CALDIS
CALM
CALR
CAM
CAMA
CAMAC
CAMIS
CAMP
CAN
CANDE
CANTRAN
CAOS
CAP
CAPDAC
CAPE
CAPP
CAPR
CAPRI
CAPS
CAR
CARD
CARESS
CARIS
CARL
CAROL
CARP
CARS
CAS
CASD
CASDAC
CASE
CASH
CASSM
CAT
CATCALL
CATCH
CATNIP
CATS
CATSS
CATV
CAU
CAV
CAVE
CAW
CAX
CB
C-BASIC
CBC
CBCT
CBE
CBI
CBL
CBM
CBMA
CBMS
CBOSS
CBS
CBT
CBX
CC
CCA
CCAM
CCAP
CCB
CCC
CCCC
CCD
CCE
CCETT
CCF
CCG
CCH
CCI
CCIA
CCIS
CCITT
CCL
CCM
CCMB
CCP
CCR
CCRH
CCS
CCSA
CCSC
CCSS
CCTV
CCU
CCW
CD
CDA
CDB
CDC
CDCT
CDCVR
CDES
CDF
CDI
CDIB
CDIS
CDK
CDL
CDMA
CDO
CDP
CDPC
CDR
CDS
CDSF
CDSH
CDSS
CDST
CDT
CDTL
CDU
CDV
CDW
CE
CEA
CED
CEF
CEI
CEM
CEO
CERT
CEU
CF
CFA
CFB
CFC
CFCE
CFDE
CFL
CFM
CFSK
CFT
CFU
CG
CGI
CGL
CGP
CGPC
CGRAM
CGS
CH
CHAMP
CHAN
CHAR
char
CHCU
CHDB
CHDL
CHI
CHIF
CHIPS
CHKPT
CHOL
CHP
CHPS
CHS
CHT
CI
CIA
CIB
CIC
CICA
CICP
CICS
CID
CIDA
CIDB
CIDS
CIF
CIG
CIL
CILE
CIM
CIN
CIOCS
CIOM
CIOP
CIOU
CIP
CIPS
CIR
CIRC
CIRCA
CIRK
CIS
CISAM
CISCO
CISDC
CISI
CIT
CIU
CL
CLA
CLAS
CLASS
CLAT
CLB
CLC
CLE
CLEO
CLF
CLG
CLI
CLIC
CLIO
CLIP
CLK
CLM
CLOB
CLOC
CLP
CLR
CLS
CLSI
CLT
CLU
CLV
CM
CMA
CMAP
CMAR
CMC
CMCA
CMD
CME
CMI
CML
CMM
CMOS
CMPX
CMR
CMS
CMT
CMU
CMX
CN
CNA
CNC
CNDP
CNE
CNI
CNP
CNR
CNS
CNT
CNU
CO
COBIS
COBLOS
COBOL
COC
COCC
COCO
COCOA
CODAP
CODASYL
CODATA
CODE
CODEC
CODES
CODIC
CODIL
CODIS
CODIT
CODOC
COED
COF
COGENT
COGO
COGS
COINS
COL
COLA
COLT
COM
COMAC
COMAL
COMBO
COMET
COMEXT
COMM
COMMS
COMNET
COMPAC
COMPACT
COMPANDOR
COMPASS
COMPAY
COMPOSE
COMPSAC
COMRADE
COMSAT
COMSL
COMSTAR
COMSYL
COMTEC
CONCORD
CONDUIT
CONF
CONIO
CONIT
CONLIS
CONSUL
CONTRAN
CONTROL
COOKI
COOL
COP
COPI
COPOL
CORAL
CORD
CORELAP
CORKS
CORS
CORSAIR
CORTEX
COS
COSAM
COSAP
COSATI
COSBA
COSCL
COSEC
COSMIC
COSOS
COSTAR
COSY
COT
COTC
COUPLE
CP
CPA
CPB
CPC
CPCI
CPCS
CPD
CPDAMS
CPDS
CPE
CPF
CPFSK
CPG
CPH
CPI
CPID
CPIN
CPL
CPM
CPMA
CPO
CPOL
CPP
CPR
CPS
CPSK
CPSM
CPSP
CPSS
CPT
CPTE
CPU
CP-V
CR
CRA
CRAM
CRAR
CRAY
CRC
CRCC
CRCGR
CRD
CRESS
CRG
CRI
CRIS
CRJE
CRL
CRO
CROM
CROS
CROSS
CROSSBOW
CRP
CRQ
CRS
CRT
CRTC
CRTOS
CRTU
CRU
CS
CSA
CSAM
CSAR
CSB
CSC
CSD
CSDM
CSDN
CSDR
CSE
CSH
CSI
CSIRONET
CSL
CSMA
CSO
CSP
CSR
CSS
CSSA
CSSL
CST
CSU
CSV
CSW
CT
CTB
CTC
CTCA
CTCP
CTD
CTE
CTI
CTL
CTMC
CTNE
CTOS
CTP
CTS
CTSI
CTSS
CU
CUA
CUBE
CUDN
CUE
CUG
CUMARC
CUP
CUSP
CUSS
CUT
CUTS
CV
CVC
CVIS
CVM
CVR
CVSD
CVT
CW
CWA
CWI
CWP
CX
CXA
CY
CYBER
CYCLADES
CZE
CZU
DA
DAA
DAB
DAC
DACBU
DACC
DACE
DACOM
DACOS
DACU
DACVR
DADB
DADS
DAF
DAFM
DAFT
DAIR
DAISY
DAL
DALK
DAM
DAMA
DAMIT
DAMP
DAMPS
DAMS
DAN
DAP
DAPS
DAPU
DAR
DARE
DARES
DARMS
DAS
DASD
DASDL
DASDR
DASF
DASH
DASL
DASS
DAT
DATAC
DATACOM
DATEL
DATEV
DATICO
DATRAN
DAU
DAV
DAVID
DB
DBA
DBAAM
DBACS
DBAF
DBAM
DBCB
DBCL
DBCS
DBD
DBDL
DBG
DBI
DBIN
DBIOC
DBLTG
DBM
DBMO
DBMOP
DBMOPS
DBMS
DBMSPSM
DBOMP
DBOS
DBP
DBQ
DBR
DBS
DBTG
DBU
DC
DCA
DCAM
DCAS
DCB
DCC
DCCS
DCCU
DCD
DCDC
DCE
DCF
DCI
DCIO
DCL
DCM
DCMS
DCN
DCNA
DCO
DC1
DC2
DC3
DC4
DCOS
DCP
DCPC
DCPCM
DCPP
DCPSK
DCR
DCRABS
DCS
DCSCS
DCT
DCTL
DCU
DCW
DD
DDA
DDAS
DDB
DDBS
DDC
DDCE
DDCMP
DDCS
DDD
DDE
DDES
DDF
DDG
DDI
DDL
DDLC
DDLG
DDM
DDMA
DDN
DDOCE
DDP
DDR
DDS
DDT
DDTE
DDTU
DDX
DE
DEA
DEAC
DEAFNET
DEAL
DEC
DECADE
DECB
DECDR
DECLAB
DECNET
DECS
DECUS
DED
DEDS
DEE
DEEDS
DEEP
DEF
DEFT
DEG
DEL
DELTA
delta
DEM
DEMOD
DEMUX
DEOT
DEP
DER
DERA
DERS
DES
DESC
DETAB
DETAP
DETOC
DETRAN
DEU
DEUA
DEUCE
DEVIL
DEX
DEXT
DF
DFA
DFAST
DFB
DFBM
DFBR
DFC
DFCNV
DFCU
DFEU
DFF
DFI
DFL
DFN
DFO
DFPL
DFS
DFSU
DFT
DG
DGBC
DGC
DGD
DGM
DGS
DGSS
DH
DHE
DHLLP
DHP
DHU
DI
DIA
DIAD
DIAL
DIAM
DIAN
DIANE
DIAS
DIB
DIBITS
DIBOL
DIBS
DIC
DICAM
DICIS
DID
DIDAD
DIDAP
DIDM
DIDO
DIDS
DIEN
DIF
DIFU
DIG
DIGICOM
DIL
DILIC
DIM
DIMS
DIN
DINA
DIO
DIOB
DIOC
DIODE
diode
DIOP
DIOS
DIP
DIPS
DIR
DISAC
DASAM
DISS
DISSPLA
DISTL
DITRAN
DIU
DIV
DIVA
DIVOT
DJSU
DKI
DL
DLA
DLC
DLCN
DLE
DLL
DLM
DLMCP
DLMF
DLOS
DLP
DLR
DLS
DLT
DLU
DM
DMA
DMAC
DMACP
DMAI
DMB
DMC
DMCL
DME
DMED
DML
DMM
DMMSC
DMOD
DMOS
DMP
DMQ
DMR
DMS
DMT
DMU
DMUS
DMX
DN
DNA
DNAM
DNC
DNCC
DNCS
DNIC
DNS
DNSC
DNT
DO
DOA
DOB
DOBIS
DOC
DOCFAX
DOCLINE
DOCS
DOCSYS
DOCUS
DOD
DODT
DOE
DOF
DOIT
DOL
DOM
DOMSAT
DOPS
DOR
DORIS
DORK
DOS
DOT
DOTSYS
DP
DPA
DPC
DPCM
DPCX
DPD
DPDL
DPE
DPEX
DPF
DPG
DPI
DPL
DPLL
DPM
DPMA
DPMC
DPO
DPP
DPPX
DPS
DPSA
DPSK
DPSS
DPTX
DPU
DQ
DR
DRA
DRAFT
DRAM
DRAW
DRC
DRCS
DRD
DRI
DRIDAC
DRIVE
DRL
DRMS
DRO
DROM
DROP
DROS
DRPS
DRQ
DRS
DRT
DRTM
DRU
DS
DSA
DSB
DSBEC
DSC
DSCB
DSCS
DSD
DSDD
DSDL
DSDS
DSE
DSF
DSI
DSID
DSL
DSLO
DSM
DSMS
DSN
DSO
DSOS
DSP
DSR
DSS
DSSD
DST
DSU
DSV
DSW
DSX
DT
DTB
DTC
DTCU
DTD
DTE
DTF
DTG
DTL
DTMF
DTMS
DTN
DTP
DTR
DTS
DTT
DTTU
DTU
DTV
DUAL
DUM
DUO
DUP
DUS
DUT
DUV
DVA
DVM
DVR
DW
DWM
DWSS
DX
DXC
DXS
DYANA
DYNASAR
DYSAC
DYSTAC
EAE
EAI
EAL
EAM
EAN
EAOS
EAPROM
EAROM
EAS
EASE
EASY
EAX
EBA
EBAM
EBCDIC
EBDIK
EBM
EBR
EBU
EC
ECAP
ECAT
ECB
ECC
ECDIN
ECER
ECHO
ECL
ECLA
ECM
ECO
ECOM
ECPS
ECS
ECT
ED
EDA
EDAC
EDB
EDC
EDD
EDGE
EDICT
EDMA
EDMS
EDP
EDPE
EDPM
EDPS
EDRS
EDS
EDSAC
EDSTAT
EDUCOM
EDUG
EDUNET
EDVAC
EDX
EEA
EEC
EEDB
EEL
EEROM
EET
EF
EFI
EFT
EFTP
EFTS
EG
EGIF
EHF
EHV
EIA
EIAJ
EIES
EIII
EIMET
EIN
EIRP
EIS
EIU
EL
ELAN
ELCOM
ELD
ELE
ELF
ELI
ELMS
ELP
ELSIE
ELSPECS
EM
EMC
EMI
EMIS
EML
EMMA
EMMS
EMOL
EMS
EMSS
EMU
EN
ENDS
ENG
ENIAC
ENQ
EOA
EOE
EOF
EOI
EOJ
EOL
EOM
EOR
EOT
EOV
EP
EPA
EPAM
EPASYS
EPB
EPC
EPCOT
EDPT
EPIA
EPIC
EPL
EPO
EPOS
EPR
EPROM
EPS
EPSS
EPU
EQ
ER
ERA
ERD
ERDA
ERES
ERFPI
ERIC
ERJE
ERL
ERP
ERT
ES
ESA
ESANET
ESC
ESCAP
ESCAPE
ESCS
ESD
ESFI
ESI
ESP
ESPL
ESPOL
ESPRIT
ESR
ESRO
ESS
ESTV
ESU
ET
ETB
ETC
ETH
ETIM
ETL
ETMF
ETP
ETR
ETS
ETSS
ETV
ETX
EU
EUF
EUV
EV
EVA
EVDS
EVE
EVIL
EVK
EVM
EVPI
EVR
EX
EXCP
EXDAMS
EXDC
EXEC
EXNOR
EXOR
EXPIO
EXR
EY
FA
FAC
FACE
FACES
FACS
FACT
FACTS
FAD
FADAC
FADS
FAHQMT
FAHQT
FAIR
FAIRS
FAKS
FAL
FALTRAN
FAM
FAMIS
FAMOS
FAMS
FAP
FAQS
FAR
FAS
FASE
FASIT
FAST
FAT
FATAR
FAX
FAXCOM
FB
FBA
FBM
FBR
FC
FCB
FCC
FCCTS
FCD
FCFO
FCFS
FCI
FCL
FCM
FCP
FCR
FCS
FCU
FCUS
FD
FDA
FDB
FDC
FDCS
FDD
FDDL
FDEP
FDIC
FDM
FDMA
FDMS
FDOS
FDP
FDR
FDS
FDSR
FDT
FDU
FDV
FDX
FE
FEA
FEAT
FEB
FEC
FECP
FEDD
FEDEX
FEDLINK
FEDNET
FEDREG
FEDS
FEFO
FEM
FEP
FES
FET
FEXT
FF
FFM
FFT
FG
FGC
FHD
FHSF
FIB
FIDAC
FIDACSYS
FIFO
FILEX
FILO
FILU
FINAC
FINFO
FIOP
FIPS
FIPSCAC
FIR
FIRL
FIRST
FIS
FIT
FIU
FIX
FIXIT
FIZ
FJCC
FL
FFLAG
FLAIR
FLDEC
FLF
FLI
FLIM
FLINT
FLIP
FLIR
FLIRT
FLIT
FLMEM
FLNPP
FLOP
FLOTRAN
FLPAU
FLPDC
FLPL
FLS
FLT
FLTSATCOM
FM
FMDU
FMIS
FML
FMLF
FMPP
FMPS
FMS
FN
FNA
FNB
FNP
FNR
FNTL
FOA
FOC
FOCAL
FOD
FOIA
FOIL
FOM
FORAST
FORC
FORCE
FORDAP
FOREM
FORGE
FORIMS
FORMAC
FORS
FORTRAN
FOSDIC
FOT
FOTS
FP
FPA
FPGA
FPH
FPL
FPLA
FPM
FPP
FPQA
FPR
FPROM
FPRS
FPS
FPSK
FPU
FQL
FQS
FR
FRB
FRC
FRED
FRESS
FRI
FRIL
FRIMP
FRINGE
FRMM
FROM
FRPS
FRR
FRXD
FS
FSCB
FSCR
FSD
FSEC
FSK
FSL
FSLIC
FSOS
FSP
FSR
FSS
FST
FSU
FT
FTA
FTC
FTET
FTF
FTL
FTP
FTPI
FTR
FTS
FTSC
FTU
FU
FUS
FVU
FW
FWA
FWL
FX
FXT
FY
FYI
GA
GAB
GALS
GAN
GAO
GAP
GASP
GASS
GAT
GATD
GATE
GATS
GB
GBF
GBLIC
GBT
GC
GCAP
GCE
GCH
GCHQ
GCI
GCOS
GCPS
GCR
GCS
GCT
GD
GDB
GDBMS
GDC
GDDL
GDE
GDF
GDI
GDL
GDM
GDMS
GDP
GDS
GDSF
GDU
GE
GEC
GECOM
GECOS
GEFRC
GEL
GELOAD
GEMCOS
GENESYS
GENIE
GENSAL
GEORGE
GERT
GERTS
GFI
GFM
GFP
GG
GHz
GIC
GIDEP
GIFS
GIFT
GIGO
GIMIC
GINO
GIOP
GIP
GIPS
GIPSY
GIRL
GIRLS
GIS
GITIS
GJP
GKS
GL
GMAP
GMIS
GML
GMP
GMR
GMS
GMSS
GMT
GN
GNC
GND
GO
GOC
GOCI
GOE
GOL
GOLEM
GOM
GOMAC
GOS
GP
GPA
GPAX
GPC
GPCA
GPD
GPDC
GPGL
GPIA
GPL
GPLAN
GPLP
GPM
GPO
GPOS
GPP
GPS
GPSDW
GPSS
GPT
GQE
GR
GRA
GRACE
GRADS
GRAIN
GRAMLIN
GRANADA
GRANIS
GRAPDEN
GRASP
GRED
GRG
GRID
GRIN
GRINDER
GRINS
GRIP
GRIPHOS
GRIPS
GROATS
GRP
GRS
GRTS
GS
GSA
GSAM
GSC
GSD
GSDS
GSE
GSI
GSIS
GSL
GSM
GSP
GSR
GT
GTD
GTDPL
GTP
GULP
HA
HAB
HAIC
HAIT
HAL
HALDIS
HALSIM
HAM
HAMT
HAPPE
HAPUB
HAR
HARP
HASP
HASQ
HAYSTAQ
HAU
HB
HBEN
HC
HCC
HCF
HCG
HCI
HCP
HCR
HCS
HD
HDA
HDAM
HDAS
HDB
HDDR
HDDS
HDF
HDI
HDLC
HDMR
HDOS
HDR
HDS
HDTV
HDU
HDX
HEALS
HEF
HELP
HEPIS
HEP
HERMES
HERS
HES
HEX
HEXFET
HF
HFAS
HFDF
HFPS
HI
HIC
HICLASS
HICS
HIDAM
HIFT
HIM
HIP
HIS
HISAM
HISARS
HISDAM
HISTLINE
HIT
HITAC
HL
HLAF
HLAIS
HLDTL
HLI
HLL
HLML
HLPI
HLR
HLS
HLSE
HLU
HMI
HMM
HMO
HMOS
HMR
HNA
HOF
HOL
HOP
HOS
HP
HPA
HPCA
HPF
HPIB
HPT
HRC
HRDP
HRM
HRNES
HRP
HRS
HRSS
HRX
HS
HSAM
HSB
HSBA
HSC
HSD
HSDB
HSEL
HSLA
HSM
HSP
HSR
HSRIOP
HSRO
HSS
HT
HTB
HTC
HTE
HTL
HTS
HUG
HV
HVG
HVR
HVTS
HW
HWI
HWIM
HYB
HYCOTRAN
Hz
IA
IAD
IADIC
IAF
IAG
IAL
IALE
IAM
IAMACS
IAMC
IAP
IAR
IARD
IAS
IASC
IASR
IBC
IBG
IBIS
IBM
IBOL
IBSR
IC
ICA
ICB
ICC
ICCF
ICCS
ICD
ICDL
ICDR
ICE
ICF
ICG
ICI
ICIC
ICIP
ICL
ICM
ICN
ICOS
ICP
ICR
ICS
ICSC
ICSMP
ICSSD
ICT
ICU
ICW
ID
IDA
IDAM
IDAS
IDB
IDBMS
IDC
IDCC
IDCS
IDD
IDDD
IDDS
IDE
IDEA
IDEN
IDEP
IDES
IDF
IDI
IDIOT
IDMAS
IDMH
IDMS
IDN
IDOS
IDP
IDPS
IDR
IDS
IDST
IDT
IE
IEEE
IEF
IEO
IES
IEV
IF
IFA
IFACE
IFAM
IFEP
IFGL
IFILE
IFM
IFO
IFR
IFS
IFU
IGFET
IGL
IGS
IGT
IH
II
IIL
IIOP
IIT
IIU
IJS
IL
ILA
ILACS
ILB
ILC
ILE
ILEM
ILL
ILM
ILO
ILP
ILS
ILTMS
IM
IMA
IMAC
IMB
IMC
IML
IMM
IMOS
IMP
IMPACT
IMPCON
IMPL
IMPS
IMR
IMRADS
IMS
IMSI
IMSP
IMT
IMU
IMX
IN
INC
Inc
INC.
Inc.
INFO
INFOL
INFORM
INGA
INGRES
INP
INS
INSAR
INSAT
INSCOPE
INSIS
INTEBRID
INTELPOST
INTELSAT
INTERMARC
INTFU
INTGEN
INTIME
INTIPS
INTRAN
INTREX
INWATS
IO
IOA
IOAU
IOB
IOBFR
IOBS
IOC
IOCTR
IOCS
IOD
IOF
IOIH
IOLA
IOLC
IOM
IOMP
IOOP
IOP
IOPG
IOPKG
IOPS
IOQ
IOR
IORB
IOREQ
IOS
IOSS
IOT
IOTA
IOTG
IP
IPA
IPB
IPC
IPCF
IPCS
IPE
IPI
IPL
IPLC
IPM
IPN
IPPF
IPS
IPSB
IPSE
IPSO
IPSOC
IPTM
IPU
IQF
IQL
IQM
IQMH
IQPP
IR
IRA
IRAM
IRC
IRED
IRF
IRFITS
IRG
IRH
IRJE
IRL
IRM
IRMS
IRN
IROS
IRQ
IRR
IRRL
IRS
IRSC
IRTU
IRTV
IRU
IRV
IRW
IRX
IS
ISA
ISAL
ISAM
ISAR
ISB
ISBD
ISBF
ISBL
ISBN
ISBS
ISC
ISCED
ISD
ISDN
ISDOS
ISDS
ISE
ISF
ISFD
ISFM
ISG
ISI
ISIC
ISILT
ISIS
ISK
ISL
ISM
ISMH
ISMS
ISO
ISP
ISR
ISRD
ISRM
ISS
ISSN
ISSP
IST
ISTIM
ISTR
ISU
IT
ITB
ITC
ITDM
ITI
ITL
ITM
ITN
ITOS
ITP
ITPS
ITR
ITS
ITV
IU
IURP
IUS
IUTS
IV
IVG
IVM
IVP
IVT
IW
IWB
IX
IXC
IXSD
JAF
JAI
JAR
JAT
JC
JCB
JCC
JCL
JCN
JCP
JCT
JDL
JEAN
JECC
JECL
JECS
JES
JETS
JFCB
JFET
JFN
JG
JIB
JIP
JK
JMSX
JN
JNT
JO
JOL
JOSS
JOVIAL
JP
JPA
JPU
JPW
JRS
JSF
JSL
JTE
JTMP
JTPS
JUG
KAR
KB
KBDSC
KBPS
KBS
KC
KCC
KCP
KCS
KCU
KDE
KDOS
KDP
KDR
KDS
KDT
KEP
KEYTECT
KF
KFAS
KGM
KHz
KICU
KIL
KIOPI
KIP
KIPO
KIS
KISS
KIT
KL
KLIC
KLU
KMON
KOPS
KP
KPC
KPH
KPIC
KPO
KR
KRL
KSAM
KSH
KSR
KTDS
KTM
KTP
KTR
KTS
KW
KWAC
KWADE
KWIC
KWIP
KWIT
KWOC
KWOT
KWUC
KYBD
LA
LAD
LADDER
LADS
LAF
LAFIS
LAG
LAHCG
LAM
LAMA
LAP
LARP
LARPS
LAS
LASER
LASP
LASS
LAU
LB
LBA
LBC
LBEN
LBN
LBR
LBT
LC
LCA
LCB
LCC
LCCC
LCCM
LCD
LCDS
LCF
LCFS
LCH
LCL
LCM
LCN
LCP
LCS
LCT
LCU
LCW
LD
LDA
LDB
LDCS
LDD
LDDS
LDLA
LDM
LDP
LDR
LDRI
LDS
LDT
LDX
LE
LEAD
LEAF
LEASAT
LED
LEF
LEGOL
LEM
LEX
LF
LFC
LFD
LFJ
LFM
LFN
LFO
LFPS
LFS
LFSR
LFU
LGN
LHF
LI
LIA
LIBCEPT
LIBRI
LIBRIS
LICOS
LID
LIFO
LIFT
LIH
LILO
LIM
LIMA
LINC
LINCS
LINUS
LIOCS
LIOP
LIPL
LIPS
LIS
LISA
LISARD
LISP
LISR
LIST
LIT
LIU
LJE
LKM
LL
LLA
LLC
LLE
LLG
LLI
LLL
LLLLL
LLM
LLN
LLS
LM
LMBI
LMI
LML
LMS
LMT
LMU
LNA
LNB
LNC
LND
LNE
LNR
LO
LOA
LOC
LOCAL
LOCAS
LOCS
LOFAR
LOGEL
LOGFED
LOGIC
LOGIPAC
LOGOL
LOLA
LOLC
LOP
LOS
LOSR
LOT
LOTIS
LOW
LP
LPA
LPC
LPCM
LPD
LPF
LPI
LPID
LPL
LPM
LPN
LPS
LPTTL
LPU
LPVT
LR
LRA
LRC
LRL
LRR
LRU
LS
LSA
LSB
LSC
LSD
LSDR
LSFR
LSG
LSI
LSID
LSL
LSLA
LSM
LSMA
LSP
LSQA
LSR
LSS
LST
LSTB
LSU
LT
LTA
LTB
LTC
LTD
LTE
LTH
LTM
LTPL
LTRS
LTS
LTU
LU
LUB
LUCK
LUE
LUF
LUG
LULU
LUN
LVA
LVLSH
LVR
LWA
LXMAR
MA
MAACS
MAB
MAC
MACCS
MACDAC
MACDACsys
MACRO
MACROCAL
MACROL
MACS
MAD
MADA
MADAM
MADAR
MADDIDA
MADE
MADM
MADR
MADRE
MADT
MAE
MAG
MAGIC
MAGTC
MAI
MAL
MALCAP
MALMARC
MAM
MANDATE
MANIAC
MANMAX
MANTIS
MAP
MAPCON
MAPPER
MAPS
MAR
MARC
MARCIVE
MARCS
MARECS
MARGIE
MARISAT
MARLIS
MARS
MARSL
MARTOS
MARVEL
MAS
MASCOT
MASER
MASM
MASS
MASSBUS
MASTER
MASTIR
MAT
MATE
MATR
MATV
MAU
MAVICA
MAX
MAXCOM
MAXNET
MB
MBANK
MBC
MBCD
MBD
MBI
MBIO
MBM
MBOS
MBPS
MBR
MBS
MBU
MC
MCA
MCAI
MCALS
MCAR
MCB
MCBF
MCC
MCCU
MCDBSU
MCEL
MCF
MCG
MCH
MCI
MCIC
MCL
MCLA
MCM
MCN
MCOS
MCP
MCPG
MCPU
MCR
MCRR
MCRS
MCS
MCT
MCU
MCVD
MCVF
MCW
MD
MDA
MDAC
MDC
MDCU
MDD
MDE
MDES
MDF
MDI
MDL
MDLC
MDM
MDMS
MDO
MDOS
MDP
MDPHI
MDPS
MDR
MDS
MDSS
MDT
MDU
ME
MEB
MEDAC
MEDI
MEDICO
MEDICS
MEDL
MEDOC
MEDTRAIN
MEF
MEI
MELCOM
MELCU
MELOP
MEME
MEP
MERLIN
MESH
META
METAPLAN
MEU
MEWT
MF
MFCA
MFCM
MFCU
MFD
MFDSUL
MF4
MFG
MFLOPS
MFLP
MFM
MFP
MFPC
MFR
MFS
MFSK
MFT
MG
MGL
MGP
MH
MHC
MHD
MHP
MHS
MHSDC
MHz
MI
MIA
MIACF
MIB
MIC
MICA
MICOS
MICR
MICRO
MICROCAT
MICROM
MICRONET
MICROPSI
MICS
MID
MIDAS
MIDDLE
MIDEF
MIDIST
MIDLNET
MIDMS
MIDS
MIFR
MIH
MIL
MIL-STD
MIM
MIMD
MIMO
MIMOLA
MIN
MIND
MINERVE
MINICS
MINIPAC
MINITEX
MINOS
MIO
MIOP
MIOS
MIP
MIPE
MIPS
MIR
MIRPS
MIRS
MIS
MISAM
MISD
MISER
MISLIC
MISMDS
MISP
MISSIL
MIST
MIT
MITA
MITOL
MITS
MIU
MIW
MKH
MKR
MKS
ML
MLA
MLC
MLCP
MLD
MLI
MLIA
MLIM
MLIP
MLP
MLS
MLTA
MLU
MM
MMAR
MMC
MMCP
MMF
MMFA
MMFM
MMI
MMIU
MML
MMOS
MMR
MMS
MMU
MN
MNA
MNCS
MNDX
MNF
MNOS
MNSC
MO
MOB
MOBIDAC
MOBL
MOBOL
MOD
MODACS
MODCOMP
MODEM
MODI
MOJ
MOL
MOLDS
MOP
MOPS
MOR
MOS
MOSAIC
MOSFET
MOUTH
MP
MPA
MPAR
MPC
MPCC
MPCI
MPCM
MPE
MPF
MPGS
MPI
MPL
MPLA
MPM
MPMC
MPO
MPP
MPPL
MPR
MPROM
MPS
MPSX
MPT
MPU
MPX
MQ
MQE
MQS
MR
MRAD
MRB
MRC
MRCS
MRDF
MRDOS
MRF
MRI
MRJE
MRL
MROM
MRR
MRS
MRT
MRWC
MS
MSA
MSAM
MSB
MSBR
MSC
MSCU
MSCW
MSD
MSDB
MSDOS
MSDS
MSEC
MSF
MSI
MSIO
MSK
MSKM
MSL
MSM
MSMLCS
MSNF
MSOS
MSP
MSR
MSS
MSSC
MSSS
MST
MSU
MSV
MT
MTA
MTBE
MTBF
MTBI
MTBM
MTC
MTCA
MTCF
MTCH
MTCS
MTCU
MTDR
MTE
MTH
MTM
MTMF
MTOS
MTP
MTPC
MTR
MTS
MTT
MTTD
MTTF
MTTR
MTTS
MTU
MTX
MU
MUF
MUI
MULTICS
MULTP
MUM
MUMPS
MUMS
MUP
MUS
MUSA
MUSICOL
MUSIL
MUSTRAN
MUTEX
MUX
MV
MVDS
MVM
MVP
MVS
MVT
MW
MWD
MWI
MWR
MWS
MXE
MXU
MYCOS
NA
NAC
NAD
NAE
NAF
NAK
NAL
NAM
NAN
NAND
NAP
NAS
NASA
NAU
NBCD
NBFM
NBM
NBMB
NBPM
NBS
NC
NCAM
NCB
NCC
NCCF
NCD
NCE
NCH
NCL
NCM
NCMT
NCN
NCP
NCR
NDBMS
NDC
NDL
NDLC
NDMS
NDOS
NDPS
NDR
NDRO
NDT
NE
NEBULA
NEC
NED
NEG
NEPHIS
NESS
NETMUX
NETSET
NEVA
NF
NFAM
NFAP
NFE
NFT
NGP
NHP
NIB
NIC
NICOL
NICS
NIDA
NIF
NIFO
NIH
NIM
NIMMS
NIP
NIPO
NIR
NIS
NISP
NISPA
NIT
NJCL
NJE
NJI
NL
NLOS
NLP
NLR
NM
NMC
NMF
NMSD
NN
NNA
NNC
NND
NOCP
NODAL
NOF
NOI
NOR
NOS
NOSP
NPD
NPIU
NPP
NPR
NPRL
NPS
NPSWL
NPT
NPU
NRDF
NRFD
NRL
NRM
NRMM
NRZ
NRZI
NS
NSC
NSF
NSI
NSM
NSP
NSS
NSU
NTE
NTF
NTI
NTIAC
NTIS
NTP
NTR
NTU
NUA
NUI
NUL
NUM
NVRAM
NVT
NWD
NZT
OA
OAF
OAP
OAQS
OARS
OAS
OASIS
OASYS
OAU
OB
OBCR
OBH
OBNA
OC
OCB
OCC
OCG
OCL
OCM
OCP
OCR
OCR-A
OCR-B
OCRS
OCS
OCT
OD
ODA
ODB
ODC
ODD
ODE
ODESY
ODG
ODP
ODR
ODT
ODU
OE
OEAP
OFIS
OFT
OFTS
OH
OIB
OIDI
OIS
OL
OLAS
OLB
OLDB
OLIFLM
OLM
OLOE
OLP
OLPARS
OLPS
OLRT
OLS
OLSUS
OLT
OLTE
OLTEP
OLTS
OLTT
OM
OMA
OMAC
OMAP
OMD
OMF
OMP
OMPR
OMR
ONI
ONT
OOPS
OP
OP-AMP
OPC
OPCODE
opcode
OPE
OPER
OPM
OPOL
OPP
OPR
OPS
OPSKS
OPSWL
OPSYS
OPT
OPTS
OPUR
OQL
O-QPSK
OR
ORACLE
ORBIT
ORC
ORE
ORICAT
ORION
ORNL
ORT
OS
OSAM
OSB
OSCL
OSCO
OSCRL
OSD
OSHB
OSI
OSIL
OSIRIS
OSL
OSM
OSN
OSR
OSS
OSSL
OT
OTC
OTE
OTF
OTG
OTL
OTRAC
OTS
OU
OUTRAN
OVD
OVID
OWF
OWL
PA
PABX
PAC
PACE
PACTEL
PACX
PAD
PADIA
PADL
PADLA
PADS
PAF
PAFC
PAGES
PAL
PALAPA
PAL-D
PAL-S
PAM
PAN
PANTHEON
PAP
PAPTC
PAR
PARC
PAS
PASCAL
PASLA
PASLIB
PASS
PAST
PAT
PATBX
PATCA
PATSY
PATX
PAU
PAX
PB
PBDG
PBN
PBS
PBU
PBX
PC
PCA
PCAM
PCB
PCC
PCCS
PCE
PCF
PCG
PCI
PCIOS
PCIS
PCjr
PCK
PCL
PCLA
PCLR
PCM
PCMI
PCMM
PCN
PCOS
PCP
PCR
PCS
PCT
PCU
PCW
PD
PDA
PDC
PDD
PDED
PDF
PDI
PDIO
PDL
PDM
PDN
PDP
PDPS
PDR
PDS
PDT
PDU
PDX
PE
PEARL
PEM
PENCIL
PEP
PEPE
PER
PERT
PES
PET
PEU
PF
PFA
PFEP
PFI
PFK
PFM
PFP
PG
PGA
PGP
PH
PHD
PI
PIA
PIB
PIC
PICA
PICU
PID
PIM
PIN
PINT
PIO
PIOCS
PIOU
PIP
PIPS
PIQ
PIR
PIRS
PISW
PIU
PIW
PJ
PKD
PL
PLA
PLACE
PLAN
PLANES
PLANET
PLAS
PLATO
PLC
PLCA
PLD
PLF
PLI
PLJ
PLL
PLM
PLO
PLP
PLPA
PLR
PLS
PLTTY
PLU
PLUS
PLZ
PM
PMA
PMAR
PMB
PMBX
PMD
PME
PMIC
PML
PMLC
PMM
PMMb
P-MOS
PMOS
PMS
PMSX
PMX
PN
PNA
PNAF
PNC
PNCC
PNP
PNSC
PO
POC
PODA
POF
POGO
POL
POLANG
POLGEN
POM
POPS
POPSI
POR
POS
POSH
POT
POTS
PP
PPB
PPC
PPD
PPE
PPI
PPIB
PPIU
PPL
PPM
PPP
PPQA
PPS
PPSS
PPT
PPU
PPX
PQA
PR
PRF
PRI
PRIMOS
PRISM
PRK
PRNET
PRO
PROCOMP
PROLOG
PROM
PROMIS
PROMP
PRONTO
PROP
PROSPO
PROXI
PRR
PRRM
PRS
PRT
PRTRC
PRU
PS
PSA
PSAM
PSB
PSCF
PSCL
PSD
PSDN
PSE
PSEC
PSI
PSIC
PSIEP
PSK
PSKM
PSL
PSLI
PSM
PSN
PSNS
PSP
PSR
PSS
PSU
PSV
PSW
PT
PTA
PTB
PTDOS
PTE
PTF
PTI
PTL
PTM
PTOS
PTP
PTR
PTS
PTSP
PTT
PTTC
PTU
PU
PUC
PUG
PUL
PUMA
PUP
PUT
PV
PVC
PVD
PVI
PVP
PVR
PVT
PMM
PWS
PX
PY
PZ
QA
QADA
QAM
QAS
QASP
QBE
QBT
QC
QCC
QE
QED
QF
QFM
QIO
QISAM
QL
QLSA
QN
QOS
QPAM
QPR
QPRS
QPSK
QRL
QRP
QRT
QS
QSL
QT
QTAM
QTH
QUAD
QUAM
QUEST
QUICKTRAN
QUIP
QVT
QWERTY
RA
RAA
RARR
RACE
RACF
RAD
RADA
RADIR
RAG
RAI
RAIN
RAIR
RAK
RALF
RALU
RAM
RAMAC
RAMIO
RAMIS
RAMP
RANDAM
RAP
RAPID
RAPS
RAR
RAROM
RAS
RASI
RASIS
RASP
RASTAC
RASTAD
RATE
RAW
RAX
RAYNET
RB
RBA
RBBS
RBD
RBE
RBF
RBM
RBS
RBT
RC
RCA
RCB
RCC
RCF
RCI
RCIU
RCP
RCS
RCU
RCV
RCVR
RCW
RD
RDA
RDAL
RDB
RDE
RDF
RDIU
RDL
RDOS
RDS
RDT
RDTC
RDY
READ
REALCOM
RECOL
RECON
REDAC
REFLECS
REFLES
REFS
REGIS
RELAY
RELCODE
REM
REMAP
REMDOS
REMSTAR
RENM
REP
REPROM
REQ
RER
RES
RESP
RETA
RETMA
RETROSPEC
REVS
REX
RF
RFA
RFD
RFDU
RFG
RFI
RFMS
RFNM
RFS
RG
RGB
RGP
RH
RHQ
RHR
RHT
RI
RIF
RIGFET
RIL
RIM
RIMS
RIN
RIO
RIOT
RIP
RIPL
RIQS
RIR
RIRA
RIRO
RIS
RJE
RJO
RJP
RL
RLA
RLC
RLD
RLF
RLG
RLL
RLR
RLSD
RM
RMA
RMB
RMC
RMF
RML
RMM
RMMU
RMON
RMOS
RMPI
RMS
RMT
RMTB
RMW
RMX
RN
RNAC
RNC
RNP
RO
ROC
ROF
ROLS
ROM
ROMIO
RONS
ROPES
ROS
ROSAR
ROSDR
ROSE
ROTH
ROTR
RP
RPC
RPG
RPI
RPL
RPM
RPN
RPQ
RPR
RPS
RPU
RR
RRA
RRAR
RRDS
RRE
RRG
RROS
RRP
RRT
RS
RSA
RSC
RSCS
RSD
RSF
RSP
RSS
RSTS
RSU
RSVP
RSX
RT
RTA
RTAC
RTAM
RTBM
RTC
RTCA
RTCC
RTCS
RTE
RTES
RTIO
RTIP
RTL
RTLP
RTM
RTMOS
RTMS
RTN
RTNR
RTOP
RTOS
RTP
RTR
RTS
RTTY
RTU
RTZ
RU
RUF
RUM
RUN
RUNTR
RVA
RVI
RVT
RWED
RWM
RWR
RWT
RX
RZ
RZNP
RZP
SA
SAB
SAC
SACCS
SAD
SADF
SADP
SADT
SAF
SAFF
SAGE
SAI
SAIL
SAINT
SAL
SALE
SALINET
SAM
SAMOS
SAMP
SAMS
SAN
SAP
SAPIR
SAR
SARM
SAS
SASI
SAT
SATCOM
SATF
SAU
SAW
SB
SBA
SBC
SBCA
SBCU
SBE
SBI
SBIR
SBR
SBS
SBT
SBU
SC
SCA
SCALD
SCAM
SCARS
SCAT
SCATS
SCATT
SCB
SCBS
SCC
SCCC
SCCS
SCCU
SCE
SCEU
SCF
SCFM
SCI
SCIM
SCIMP
SCL
SCM
SCN
SCOBOL
SCOOP
SCOPE
SCORPIO
SCP
SCPC
SCPI
SCR
SCS
SCSI
SCSU
SCT
SCTE
SCU
SCULL
SD
SDA
SDAID
SDAL
SDB
SDBP
SDCR
SDD
SDDL
SDE
SDF
SDFS
SDI
SDIO
SDK
SDL
SDLC
SDM
SDMA
SDMS
SDN
SDP
SDR
SDSI
SDSW
SDU
SDW
SDX
SE
SEAM
SEARCH
SEC
SECAM
SECO
SECU
SEDIM
SEEA
SEF
SEG
SEL
SELBUS
SEM
SEMCOR
SEMI
SEMS
SEN
SENECA
SEP
SEQUEL
SER
SERCNET
SERF
SES
SESE
SET
SETF
SF
SFA
SFC
SFE
SFF
SFL
SFM
SFP
SFS
SFU
SG
SGD
SGJP
SGML
SH
SHARES
SHARP
SAHU
SHF
SHFTR
SHL
SHOC
SI
SIA
SIAM
SIB
SIC
SICOB
SICOMP
SID
SIDES
SIF
SIFT
SIG
SIL
SILT
SIM
SIMD
SIMILE
SIMON
SIMP
SIMPLE
SIMS
SIN
SIO
SIOC
SIP
SIR
SIRIO
SIS
SIT
SITE
SITL
SIU
SJF
SJP
SKB
SKIL
SKWOC
SL
SLA
SLAM
SLANG
SLC
SLCM
SLCU
SLD
SLDTSS
SLE
SLI
SLIC
SLIH
SLIP
SLIPR
SLISP
SLM
SLO
SLOCOP
SLOSRI
SLP
SLR
SLS
SLSI
SLT
SLTF
SLU
SM
SMA
SMAL
SMART
SMB
SMC
SMD
SMDR
SMEM
SMI
SMIP
SMIS
SML
SMLCC
SMM
SMMC
SMP
SMR
SMRT
SMS
SMU
SMUT
SMX
SN
SNA
SNAFU
SNAP
SNB
SNBU
SNI
SNOBOL
SNP
SNR
SNS
SO
SOA
SOAP
SOB
SOCCS
SOCO
SOCRATES
SOD
SOF
SOH
SOL
SOLAR
SOLINET
SOLINEWS
SOLOMON
SOLUG
SOM
SOMADA
SOP
SOR
SORM
SOS
SOT
SOTA
SOUP
SP
SPA
SPACE
SPADE
SPAM
SPAN
SPASM
SPAU
SPB
SPC
SPCS
SPD
SPDM
SPE
SPEAKEASY
SPEDE
SPEED
SPF
SPI
SPIDAC
SPIN
SPINDEX
SPIRES
SPIS
SPL
SPLC
SPM
SPMOL
SPN
SPNS
SPO
SPOOF
SPOOL
SPP
SPR
SPRING
SPROM
SPS
SPSS
SPT
SPTF
SPU
SPUR
SPWM
SQA
SQD
SQL
SQNCR
SR
SRAM
SRB
SRCNET
SRCR
SRE
SRF
SRI
SRL
SRM
SRP
SRS
SRZ
SS
SSA
SSAC
SSB
SSBAM
SSBM
SSBSC
SSB-SC
SSC
SSCI
SSDA
SSDC
SSDD
SSDR
SSF
SSG
SSI
SSIE
SSL
SSLC
SSM
SSMF
SSN
SSP
SSR
SSRS
SST
SSTDMA
SSTF
SSTV
SSU
ST
STA
STAC
STAIRS
STAM
STAR
STARFIRE
STAT
STB
STC
STCB
STD
STDM
STDN
STE
STEP
STF
STI
STIR
STL
STLB
STM
STN
STO
STOL
STOQ
STP
STPL
STR
STRAIN
STRN
STRUDL
STS
STSI
STT
STTC
STW
STX
SU
SUB
SUI
SUM
SUN
SURGE
SUS
SUSY
SV
SVA
SVC
SVDF
SVI
SVM
SVP
SVR
SVS
SVT
SW
SWA
SWADS
SWAMI
SWAP
SWE
SWI
SWIFT
SWIFTLASS
SWIFTSIR
SX
SXS
SY
SYFA
SYLCU
SYLK
SYN
SYNC
SYSIN
SYSOUT
SYSTRAN
SYU
SZ
TAB
TABSIM
TABSOL
TAC
TACOS
TACS
TACT
TAD
TAF
TAG
TAL
TAM
TAMOS
TAP
TARDIS
TARP
TAS
TASC
TASCON
TASS
TAT
TAU
TB
TBC
TBEM
TBM
TBR
TC
TCAM
TCB
TCBH
TCIS
TCL
TCM
TCMF
TCP
TCR
TCS
TCU
TD
TDA
TDB
TDCS
TDE
TDG
TDI
TDL
TDM
TDMA
TDOS
TDPL
TDR
TDRS
TDS
TDTL
TDX
TE
TEAM
TEBOL
TEC
TED
TEDS
TEG
TEGAS
TEL
TELECOM
TELEFAX
TELEMAIL
TELENET
TELEPACK
TELESET
TELEX
TELIDON
TELTIPS
TEMPOS
TEP
TEPOS
TES
TESLA
TEX
TEXPLOT
TF
TFM
TFMS
TFR
TFS
TFT
TG
TH
THD
THOR
THP
THQ
THR
TI
TICS
TIDF
TIDMA
TIE
TIF
TIGER
TIGS
TIH
TIM
TIMS
TINDX
TINET
TIO
TIOC
TIOT
TIP
TIPS
TIQ
TIR
TIS
TIU
TJID
TKO
TL
TLB
TLC
TLCT
TLMS
TLN
TLP
TLS
TLSA
TLU
TM
TMC
TMF
TMP
TMR
TMS
TMU
TMXO
TN
TNDC
TNF
TOADS
TOCS
TOD
TODS
TOL
TOLAR
TOLTEP
TOLTS
TOOL
TOPS
TOS
TOSCIN
TOSL
TOSS
TP
TPA
TPAM
TPD
TPFI
TPG
TPI
TPL
TPMM
TPMS
TPNS
TPS
TPU
TQE
TR
TRACS
TRAMP
TRAN
TRANSMUX
TRC
TRE
TREM
TRF
TRIB
TRIM
TRISNET
TRK
TRL
TRM
TROS
TRQ
TRR
TRT
TRTL
TS
TSA
TSAM
TSB
TSC
TSCT
TSE
TSI
TSID
TSIU
TSL
TSM
TSN
TSO
TSOS
TSP
TSPS
TSR
TSS
TSSMCP
TST
TSU
TSW
TSX
TT
TTD
TTDL
TTL
TTLS
TTR
TTS
TTSPN
TTY
TTYC
TTYPP
TU
TUF
TV
TVA
TVC
TVDR
TVR
TVRO
TVS
TVT
TVW
TW
TWA
TWB
TWP
TWR
TWS
TWT
TWTA
TWX
TX
TXD
TXDS
TXE
TXK
TXS
UA
UAC
UACN
UAP
UAR
UART
UAX
UBC
UBL
UC
UCB
UCC
UCF
UCI
UCLA
UCM
UCMP
UCP
UCS
UCSD
UCW
UD
UDAC
UDAS
UDC
UDE
UDL
UDR
UDS
UDTS
UE
UET
UF
UFAM
UFC
UFD
UFEDS
UFI
UFM
UFP
UHF
UHL
UHR
UHRF
UIC
UIG
UIO
UIOC
UIR
UJCL
UL
ULA
ULC
ULISYS
ULM
ULSI
UMC
UMF
UMI
UMLC
UMS
UN
UNALC
UNCM
UNCOL
UNDEX
UNESCO
UNIBUS
UNICOMP
UNIMARC
UNIQUE
UNISTAR
UNIVAC
UP
UPACS
UPC
UPI
UPL
UPP
UPS
UPSI
UPT
UPU
UQT
UR
URA
URC
URL
URP
US
USAM
USART
USASCII
USASCSOCR
USAI
USB
USER
USI
USIO
USPS
USR
USRT
UT
UTA
UTD
UTOL
UTS
UTTC
UUT
UV
UVPROM
UWA
VA
VAA
VAB
VAC
VACC
VADAC
VADC
VAM
VAMP
VANS
VAS
VAT
VAU
VB
VBI
VBOMF
VBP
VC
VCA
VCBA
VCC
VCF
VCG
VCO
VCP
VCR
VCRO
VCS
VCTCA
VD
VDA
VDAM
VDB
VDC
VDE
VDETS
VDG
VDI
VDP
VDR
VDS
VDT
VDU
VDUC
VEA
VENUS
VET
VF
VFB
VFC
VFCT
VFL
VFMED
VFO
VFT
VFU
VGAM
VGU
VHA
VHD
VHF
VHLL
VHM
VHOL
VHPIC
VHR
VHS
VHSI
VHSIC
VIA
VIBL
VIC
VICAM
VICAR
VIDEO
VIDIAC
VIO
VIP
VIPS
VIR
VIROC
VISC
VIU
VIURAM
VLF
VLP
VLS
VLSI
VLSW
VM
VMA
VMAPS
VMCB
VMCF
VME
VMID
VML
VMM
VMOS
VMT
VNC
VNL
VOCODER
VOGAD
VOL
VOM
VORTEX
VOS
VOSC
VOTERM
VOTES
VP
VPAM
VPN
VPS
VPSW
VPZ
VR
VRAM
VRC
VRF
VRM
VROM
VRP
VRU
VRX
VS
VSAM
VSB
VSBS
VSC
VSDM
VSE
VSI
VSL
VSMF
VSN
VSPC
VSS
VSWR
VT
VTAC
VTAM
VTDI
VTOC
VTP
VTR
VTS
VTTC
VU
VWS
WACK
WADEX
WADS
WAK
WAN
WAP
WASAR
WAT
WATCON
WATFIV
WATFOR
WATS
WB
WBS
WC
WCB
WCF
WCGM
WCI
WCL
WCM
WCR
WCS
WCY
WD
WDCS
WE
WESTAR
WFL
WGN
WIS
WISI
WKQDR
WL
WM
WO
WOM
WP
WPDA
WPM
WPR
WPS
WR
WRAIS
WRIU
WRU
WS
WSF
WST
WT
WU
WUC
WW
WWMCCS
XB
XBC
XBM
XBT
XCS
XCU
XD
XDS
XDUP
XFC
XFER
Xfer
XGP
XICS
XIO
XIOP
XIT
XL
XM
XMOS
XMS
XMTR
XNOS
XOP
XOR
XOS
XPD
XPI
XPSW
XPT
XR
XRM
XTAL
XTC
XTEN
YAG
YEC
YR
YTD
ZAPP
ZBID
ZCR
ZDS
ZI
ZIF
ZLC
ZOH
ZPB
ZRM