Compute the occurrences after removal of duplicates, not before.

6 files changed, 750 insertions, 673 deletions

diff --git a/ChangeLog b/ChangeLog
index 2553a1b..d874b13 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,17 @@
 2002-11-03  Bruno Haible  <bruno@clisp.org>
 
+	Compute the occurrences after removal of duplicates, not before.
+	* src/keyword.h (KeywordExt::init_selchars): Remove occurrences
+	argument.
+	* src/keyword.cc (KeywordExt::init_selchars): Likewise.
+	* src/search.cc (Search::prepare): Reorder the code. Compute the
+	occurrences after removal of duplicates.
+	(Search::merge_sort): Optimize the loop.
+	(Search::compute_occurrence): Renamed from Search::get_occurrence.
+	* src/search.h (Search::compute_occurrence): Renamed from
+	Search::get_occurrence.
+	* tests/chill.exp: Regenerated.
+
 	Bug fix: The hash table could fail to detect duplicates, between
 	keywords of different length, when option -n (option[NOLENGTH]) was
 	given.
diff --git a/src/keyword.cc b/src/keyword.cc
index a7aae2c..a839e42 100644
--- a/src/keyword.cc
+++ b/src/keyword.cc
@@ -47,7 +47,7 @@ static inline void sort_char_set (unsigned char *base, int len)
     }
 }
 
-/* Initialize selchars and selchars_length, and update occurrences.
+/* Initialize selchars and selchars_length.
    The hash function will be computed as
    asso_values[allchars[key_pos[0]]] + asso_values[allchars[key_pos[1]]] + ...
    We compute selchars as the multiset
@@ -57,7 +57,7 @@ static inline void sort_char_set (unsigned char *base, int len)
    Furthermore we sort the selchars array, to ease detection of duplicates
    later.
  */
-void KeywordExt::init_selchars (int *occurrences)
+void KeywordExt::init_selchars ()
 {
   const char *k = _allchars;
   unsigned char *key_set =
@@ -69,14 +69,13 @@ void KeywordExt::init_selchars (int *occurrences)
     for (int i = _allchars_length; i > 0; k++, i--)
       {
         *ptr = static_cast<unsigned char>(*k);
-        occurrences[*ptr]++;
         ptr++;
       }
   else
     /* Only use those character positions specified by the user.  */
     {
-      /* Iterate through the list of key_positions, initializing occurrences
-         table and selchars (via ptr).  */
+      /* Iterate through the list of key_positions, initializing selchars
+         (via ptr).  */
       PositionIterator iter (option.get_key_positions ());
 
       for (int i; (i = iter.next ()) != PositionIterator::EOS; )
@@ -90,7 +89,6 @@ void KeywordExt::init_selchars (int *occurrences)
           else
             /* Out of range of KEY length, so we'll just skip it.  */
             continue;
-          occurrences[*ptr]++;
           ptr++;
         }
 
diff --git a/src/keyword.h b/src/keyword.h
index 5dbd399..cc754ba 100644
--- a/src/keyword.h
+++ b/src/keyword.h
@@ -56,12 +56,14 @@ struct KeywordExt : public Keyword
      multiset.  */
   const unsigned char * _selchars;
   int                   _selchars_length;
-  /* Chained list of keywords having the same selchars.  */
+  /* Chained list of keywords having the same _selchars and
+     - if !option[NOLENGTH] - also the same _allchars_length.
+     Note that these duplicates are not members of the main keyword list.  */
   KeywordExt *          _duplicate_link;
 
   /* Methods depending on the keyposition list.  */
-  /* Initialize selchars and selchars_length, and update occurrences.  */
-  void                  init_selchars (int *occurrences);
+  /* Initialize selchars and selchars_length.  */
+  void                  init_selchars ();
 
   /* Data members used by the algorithm.  */
   int                   _occurrence; /* Frequency of key set occurrences.  */
diff --git a/src/search.cc b/src/search.cc
index 1f39f54..349885a 100644
--- a/src/search.cc
+++ b/src/search.cc
@@ -41,6 +41,8 @@ Search::Search (KeywordExt_List *list)
     _asso_values (new int[_alpha_size]),
     _determined (new bool[_alpha_size])
 {
+  memset (_asso_values, 0, _alpha_size * sizeof (_asso_values[0]));
+  memset (_determined, 0, _alpha_size * sizeof (_determined[0]));
 }
 
 void
@@ -48,42 +50,67 @@ Search::prepare ()
 {
   KeywordExt_List *temp;
 
+  /* Compute the total number of keywords.  */
   _total_keys = 0;
   for (temp = _head; temp; temp = temp->rest())
+    _total_keys++;
+
+  /* Initialize each keyword's _selchars array.  */
+  for (temp = _head; temp; temp = temp->rest())
+    temp->first()->init_selchars();
+
+  /* Compute the minimum and maximum keyword length.  */
+  _max_key_len = INT_MIN;
+  _min_key_len = INT_MAX;
+  for (temp = _head; temp; temp = temp->rest())
     {
-      temp->first()->init_selchars(_occurrences);
-      _total_keys++;
+      KeywordExt *keyword = temp->first();
+
+      if (_max_key_len < keyword->_allchars_length)
+        _max_key_len = keyword->_allchars_length;
+      if (_min_key_len > keyword->_allchars_length)
+        _min_key_len = keyword->_allchars_length;
     }
 
-  _list_len = _total_keys;
+  /* Exit program if an empty string is used as key, since the comparison
+     expressions don't work correctly for looking up an empty string.  */
+  if (_min_key_len == 0)
+    {
+      fprintf (stderr, "Empty input key is not allowed.\n"
+                       "To recognize an empty input key, your code should check for\n"
+                       "len == 0 before calling the gperf generated lookup function.\n");
+      exit (1);
+    }
 
+  /* Check for duplicates, i.e. keywords with the same _selchars array
+     (and - if !option[NOLENGTH] - also the same length).
+     We deal with these by building an equivalence class, so that only
+     1 keyword is representative of the entire collection.  Only this
+     representative remains in the keyword list; the others are accessible
+     through the _duplicate_link chain, starting at the representative.
+     This *greatly* simplifies processing during later stages of the program.
+     Set _total_duplicates and _list_len = _total_keys - _total_duplicates.  */
   {
-    /* Make hash table for efficiency. */
-    Hash_Table found_link (_list_len, option[NOLENGTH]);
-
-    /* Test whether there are any links and also set the maximum length of
-       an identifier in the keyword list. */
+    _list_len = _total_keys;
     _total_duplicates = 0;
-    _max_key_len = INT_MIN;
-    _min_key_len = INT_MAX;
-    KeywordExt_List *trail = NULL;
+    /* Make hash table for efficiency.  */
+    Hash_Table representatives (_list_len, option[NOLENGTH]);
+
+    KeywordExt_List *prev = NULL; /* list node before temp */
     for (temp = _head; temp; temp = temp->rest())
       {
         KeywordExt *keyword = temp->first();
-        KeywordExt *other_keyword = found_link.insert (keyword);
-
-        /* Check for links.  We deal with these by building an equivalence class
-           of all duplicate values (i.e., links) so that only 1 keyword is
-           representative of the entire collection.  This *greatly* simplifies
-           processing during later stages of the program. */
+        KeywordExt *other_keyword = representatives.insert (keyword);
 
         if (other_keyword)
           {
             _total_duplicates++;
             _list_len--;
-            trail->rest() = temp->rest();
-            temp->first()->_duplicate_link = other_keyword->_duplicate_link;
-            other_keyword->_duplicate_link = temp->first();
+            /* Remove keyword from the main list.  */
+            prev->rest() = temp->rest();
+            /* And insert it on other_keyword's duplicate list.  */
+            keyword->_duplicate_link = other_keyword->_duplicate_link;
+            other_keyword->_duplicate_link = keyword;
 
             /* Complain if user hasn't enabled the duplicate option. */
             if (!option[DUP] || option[DEBUG])
@@ -94,19 +121,16 @@ Search::prepare ()
           }
         else
           {
-            temp->first()->_duplicate_link = NULL;
-            trail = temp;
+            keyword->_duplicate_link = NULL;
+            prev = temp;
           }
-
-        /* Update minimum and maximum keyword length, if needed. */
-        if (_max_key_len < keyword->_allchars_length)
-          _max_key_len = keyword->_allchars_length;
-        if (_min_key_len > keyword->_allchars_length)
-          _min_key_len = keyword->_allchars_length;
       }
   }
 
-  /* Exit program if links exists and option[DUP] not set, since we can't continue */
+  /* Exit program if duplicates exists and option[DUP] not set, since we
+     don't want to continue in this case.  (We don't want to turn on
+     option[DUP] implicitly, because the generated code is usually much
+     slower.  */
   if (_total_duplicates)
     {
       if (option[DUP])
@@ -119,20 +143,23 @@ Search::prepare ()
           exit (1);
         }
     }
-  /* Exit program if an empty string is used as key, since the comparison
-     expressions don't work correctly for looking up an empty string. */
-  if (_min_key_len == 0)
+
+  /* Compute the occurrences of each character in the alphabet.  */
+  memset (_occurrences, 0, _alpha_size * sizeof (_occurrences[0]));
+  for (temp = _head; temp; temp = temp->rest())
     {
-      fprintf (stderr, "Empty input key is not allowed.\nTo recognize an empty input key, your code should check for\nlen == 0 before calling the gperf generated lookup function.\n");
-      exit (1);
+      KeywordExt *keyword = temp->first();
+      const unsigned char *ptr = keyword->_selchars;
+      for (int count = keyword->_selchars_length; count > 0; ptr++, count--)
+        _occurrences[*ptr]++;
     }
 }
 
-/* Recursively merges two sorted lists together to form one sorted list. The
-   ordering criteria is by frequency of occurrence of elements in the key set
-   or by the hash value.  This is a kludge, but permits nice sharing of
-   almost identical code without incurring the overhead of a function
-   call comparison. */
+/* Merges two sorted lists together to form one sorted list.
+   The sorting criterion depends on which of _occurrence_sort and _hash_sort
+   is set to true.  This is a kludge, but permits nice sharing of almost
+   identical code without incurring the overhead of a function call for
+   every comparison.  */
 
 KeywordExt_List *
 Search::merge (KeywordExt_List *list1, KeywordExt_List *list2)
@@ -151,8 +178,10 @@ Search::merge (KeywordExt_List *list1, KeywordExt_List *list2)
           *resultp = list1;
           break;
         }
-      if (_occurrence_sort && list1->first()->_occurrence < list2->first()->_occurrence
-          || _hash_sort && list1->first()->_hash_value > list2->first()->_hash_value)
+      if ((_occurrence_sort
+           && list1->first()->_occurrence < list2->first()->_occurrence)
+          || (_hash_sort
+              && list1->first()->_hash_value > list2->first()->_hash_value))
         {
           *resultp = list2;
           resultp = &list2->rest(); list2 = list1; list1 = *resultp;
@@ -166,37 +195,46 @@ Search::merge (KeywordExt_List *list1, KeywordExt_List *list2)
   return result;
 }
 
-/* Applies the merge sort algorithm to recursively sort the key list by
-   frequency of occurrence of elements in the key set. */
+/* Sorts a list using the recursive merge sort algorithm.
+   The sorting criterion depends on which of _occurrence_sort and _hash_sort
+   is set to true.  */
 
 KeywordExt_List *
 Search::merge_sort (KeywordExt_List *head)
 {
   if (!head || !head->rest())
+    /* List of length 0 or 1.  Nothing to do.  */
     return head;
   else
     {
+      /* Determine a list node in the middle.  */
       KeywordExt_List *middle = head;
-      KeywordExt_List *temp   = head->rest()->rest();
-
-      while (temp)
+      for (KeywordExt_List *temp = head->rest();;)
         {
-          temp   = temp->rest();
+          temp = temp->rest();
+          if (temp == NULL)
+            break;
+          temp = temp->rest();
           middle = middle->rest();
-          if (temp)
-            temp = temp->rest();
+          if (temp == NULL)
+            break;
         }
 
-      temp         = middle->rest();
-      middle->rest() = 0;
-      return merge (merge_sort (head), merge_sort (temp));
+      /* Cut the list into two halves.
+         If the list has n elements, the left half has ceiling(n/2) elements
+         and the right half has floor(n/2) elements.  */
+      KeywordExt_List *right_half = middle->rest();
+      middle->rest() = NULL;
+
+      /* Sort the two halves, then merge them.  */
+      return merge (merge_sort (head), merge_sort (right_half));
     }
 }
 
 /* Returns the frequency of occurrence of elements in the key set. */
 
 inline int
-Search::get_occurrence (KeywordExt *ptr)
+Search::compute_occurrence (KeywordExt *ptr)
 {
   int value = 0;
 
@@ -249,7 +287,7 @@ Search::reorder ()
     {
       KeywordExt *keyword = ptr->first();
 
-      keyword->_occurrence = get_occurrence (keyword);
+      keyword->_occurrence = compute_occurrence (keyword);
     }
 
   _hash_sort = false;
diff --git a/src/search.h b/src/search.h
index 12b3c7a..c6a9b3e 100644
--- a/src/search.h
+++ b/src/search.h
@@ -37,9 +37,13 @@ public:
   void                  optimize ();
 private:
   void                  prepare ();
+
+  /* Merges two sorted lists together to form one sorted list.  */
   KeywordExt_List *     merge (KeywordExt_List *list1, KeywordExt_List *list2);
+  /* Sorts a list using the recursive merge sort algorithm.  */
   KeywordExt_List *     merge_sort (KeywordExt_List *head);
-  int                   get_occurrence (KeywordExt *ptr);
+
+  int                   compute_occurrence (KeywordExt *ptr);
   void                  set_determined (KeywordExt *ptr);
   bool                  already_determined (KeywordExt *ptr);
   void                  reorder ();
@@ -53,21 +57,44 @@ private:
   void                  change (KeywordExt *prior, KeywordExt *curr);
   void                  sort ();
 public:
-  KeywordExt_List *     _head;                            /* Points to the head of the linked list. */
-  int                   _total_keys;                           /* Total number of keys, counting duplicates. */
-  int                   _total_duplicates;                     /* Total number of duplicate hash values. */
-  int                   _max_key_len;                          /* Maximum length of the longest keyword. */
-  int                   _min_key_len;                          /* Minimum length of the shortest keyword. */
-  /* Size of alphabet. */
+
+  /* Linked list of keywords.  */
+  KeywordExt_List *     _head;
+
+  /* Total number of keywords, counting duplicates.  */
+  int                   _total_keys;
+
+  /* Total number of duplicates that have been moved to _duplicate_link lists
+     (not counting their representatives which stay on the main list).  */
+  int                   _total_duplicates;
+
+  /* Maximum length of the longest keyword.  */
+  int                   _max_key_len;
+
+  /* Minimum length of the shortest keyword.  */
+  int                   _min_key_len;
+
+  /* Size of alphabet.  */
   int const             _alpha_size;
-  /* Counts occurrences of each key set character. */
+
+  /* Counts occurrences of each key set character.
+     _occurrences[c] is the number of times that c occurs among the _selchars
+     of a keyword.  */
   int * const           _occurrences;
   /* Value associated with each character. */
   int * const           _asso_values;
+
 private:
-  int                   _list_len;                             /* Length of head's Key_List, not counting duplicates. */
-  bool                  _occurrence_sort;                      /* True if sorting by occurrence. */
-  bool                  _hash_sort;                            /* True if sorting by hash value. */
+
+  /* Length of _head list.  Number of keywords, not counting duplicates.  */
+  int                   _list_len;
+
+  /* Choice of sorting criterion during Search::merge_sort.  */
+  /* True if sorting by occurrence.  */
+  bool                  _occurrence_sort;
+  /* True if sorting by hash value.  */
+  bool                  _hash_sort;
+
   bool * const          _determined;                           /* Used in function reorder, below. */
   int                   _num_done;          /* Number of keywords processed without a collision. */
   int                   _fewest_collisions; /* Records fewest # of collisions for asso value. */
diff --git a/tests/chill.exp b/tests/chill.exp
index 24380de..d0504fc 100644
--- a/tests/chill.exp
+++ b/tests/chill.exp
@@ -7,7 +7,7 @@ struct resword {
   enum toktype { RESERVED, DIRECTIVE, PREDEF } flags;
 };
 extern tree ridpointers [];
-/* maximum key range = 2815, duplicates = 6 */
+/* maximum key range = 2652, duplicates = 6 */
 
 #ifdef __GNUC__
 __inline
@@ -23,32 +23,32 @@ hash (str, len)
 {
   static unsigned short asso_values[] =
     {
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822,    4,   61,   80,   12,  350,
-        91,   39,    3,    2, 2822,    4,  129,  155,   64,   46,
-        65, 2822,   96,   13,    1,  135,    7,    2,    8,  124,
-         7, 2822, 2822, 2822, 2822,    1, 2822,   94,   40,  127,
-        21,    1,   81,    1,    1,    7, 2822,    3,   23,   74,
-       255,  203,   70, 2822,  218,    1,   88,  124,    1,    6,
-        10,   56,   40, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
-      2822, 2822, 2822, 2822, 2822, 2822
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692,  141,   74,   44,  107,    1,
+       208,    1,    1,   22, 2692,    4,   43,  195,  151,   67,
+        60, 2692,   64,   11,  452,   42,   11,    2,    3,   48,
+         8, 2692, 2692, 2692, 2692,    1, 2692,    6,   52,   37,
+        93,    1,   78,    1,   15,    7, 2692,    2,  119,   52,
+       345,  231,   33, 2692,   92,    1,  233,   60,    1,    2,
+         1,   80,   25, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692, 2692,
+      2692, 2692, 2692, 2692, 2692, 2692
     };
   register int hval = len;
 
@@ -133,312 +133,312 @@ in_word_set (str, len)
       TOTAL_KEYWORDS = 300,
       MIN_WORD_LENGTH = 2,
       MAX_WORD_LENGTH = 30,
-      MIN_HASH_VALUE = 7,
-      MAX_HASH_VALUE = 2821
+      MIN_HASH_VALUE = 40,
+      MAX_HASH_VALUE = 2691
     };
 
   static struct resword wordlist[] =
     {
-      {"AT",			AT,			NORID,	RESERVED},
-      {"WITH",			WITH,			NORID,	RESERVED},
-      {"THIS",			THIS,			NORID,	RESERVED},
-      {"else",			ELSE,			NORID,	RESERVED},
-      {"while",			WHILE,			NORID,	RESERVED},
-      {"TO",			TO,			NORID,	RESERVED},
       {"seize",			SEIZE,			NORID,	RESERVED},
-      {"DO",			DO,			NORID,	RESERVED},
-      {"OD",			OD,			NORID,	RESERVED},
-      {"BIT",			BOOLS,			RID_BOOLS,	PREDEF},
-      {"IN",			IN,			RID_IN,	RESERVED},
-      {"INIT",			INIT,			NORID,	RESERVED},
-      {"AND",			AND,			NORID,	RESERVED},
+      {"page",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"SEIZE",			SEIZE,			NORID,	RESERVED},
+      {"case",			CASE,			NORID,	RESERVED},
+      {"esac",			ESAC,			NORID,	RESERVED},
+      {"ELSE",			ELSE,			NORID,	RESERVED},
+      {"asm",			ASM_KEYWORD,		NORID,	RESERVED},
+      {"WHILE",			WHILE,			NORID,	RESERVED},
+      {"spec",			SPEC,			NORID,	RESERVED},
+      {"EVER",			EVER,			NORID,	RESERVED},
+      {"pack",			PACK,			NORID,	RESERVED},
       {"fi",			FI,			NORID,	RESERVED},
       {"if",			IF,			NORID,	RESERVED},
-      {"set",			SET,			NORID,	RESERVED},
-      {"FI",			FI,			NORID,	RESERVED},
-      {"IF",			IF,			NORID,	RESERVED},
-      {"by",			BY,			NORID,	RESERVED},
-      {"this",			THIS,			NORID,	RESERVED},
-      {"with",			WITH,			NORID,	RESERVED},
-      {"STATIC",			STATIC,			NORID,	RESERVED},
-      {"exit",			EXIT,			NORID,	RESERVED},
-      {"ON",			ON,			NORID,	RESERVED},
-      {"NOT",			NOT,			NORID,	RESERVED},
-      {"elsif",			ELSIF,			NORID,	RESERVED},
-      {"START",			START,			NORID,	RESERVED},
-      {"list",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"POS",			POS,			NORID,	RESERVED},
-      {"DOWN",			DOWN,			NORID,	RESERVED},
-      {"STOP",			STOP,			NORID,	RESERVED},
-      {"BIN",			BIN,			NORID,	RESERVED},
-      {"GOTO",			GOTO,			NORID,	RESERVED},
-      {"bit",			BOOLS,			RID_BOOLS,	PREDEF},
-      {"OF",			OF,			NORID,	RESERVED},
-      {"all",			ALL,			NORID,	RESERVED},
+      {"access",			ACCESS,			NORID,	RESERVED},
+      {"up",			UP,			NORID,	RESERVED},
+      {"ever",			EVER,			NORID,	RESERVED},
+      {"UP",			UP,			NORID,	RESERVED},
+      {"cause",			CAUSE,			NORID,	RESERVED},
+      {"SPEC",			SPEC,			NORID,	RESERVED},
+      {"BY",			BY,			NORID,	RESERVED},
+      {"else",			ELSE,			NORID,	RESERVED},
       {"OR",			OR,			NORID,	RESERVED},
+      {"by",			BY,			NORID,	RESERVED},
       {"ROW",			ROW,			NORID,	RESERVED},
-      {"LIST",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"XOR",			XOR,			NORID,	RESERVED},
-      {"PACK",			PACK,			NORID,	RESERVED},
+      {"POS",			POS,			NORID,	RESERVED},
+      {"receive",		RECEIVE,		NORID,	RESERVED},
+      {"rem",			REM,			NORID,	RESERVED},
+      {"while",			WHILE,			NORID,	RESERVED},
+      {"RECEIVE",		RECEIVE,		NORID,	RESERVED},
+      {"chars",			CHARS,			NORID,	RESERVED},
+      {"LOC",			LOC,			NORID,	RESERVED},
       {"based",			BASED,			NORID,	RESERVED},
-      {"step",			STEP,			NORID,	RESERVED},
-      {"page",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"asm",			ASM_KEYWORD,		NORID,	RESERVED},
-      {"dcl",			DCL,			NORID,	RESERVED},
-      {"ASM",			ASM_KEYWORD,		NORID,	RESERVED},
-      {"ANDIF",			ANDIF,			NORID,	RESERVED},
+      {"EVEN",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"ref",			REF,			NORID,	RESERVED},
+      {"IN",			IN,			RID_IN,	RESERVED},
+      {"DO",			DO,			NORID,	RESERVED},
+      {"OD",			OD,			NORID,	RESERVED},
+      {"far",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"CYCLE",			CYCLE,			NORID,	RESERVED},
+      {"read",			READ,			RID_READ,	RESERVED},
+      {"DCL",			DCL,			NORID,	RESERVED},
+      {"CASE",			CASE,			NORID,	RESERVED},
+      {"ESAC",			ESAC,			NORID,	RESERVED},
+      {"PAGE",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"elsif",			ELSIF,			NORID,	RESERVED},
+      {"SYN",			SYN,			NORID,	RESERVED},
       {"simple",			SIMPLE,			NORID,	RESERVED},
+      {"ON",			ON,			NORID,	RESERVED},
+      {"large",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"ALL",			ALL,			NORID,	RESERVED},
+      {"FI",			FI,			NORID,	RESERVED},
+      {"IF",			IF,			NORID,	RESERVED},
+      {"set",			SET,			NORID,	RESERVED},
+      {"PROC",			PROC,			NORID,	RESERVED},
       {"at",			AT,			NORID,	RESERVED},
-      {"OUT",			PARAMATTR,		RID_OUT,	RESERVED},
-      {"BY",			BY,			NORID,	RESERVED},
-      {"text",			TEXT,			NORID,	RESERVED},
-      {"FAR",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"up",			UP,			NORID,	RESERVED},
-      {"delay",			DELAY,			NORID,	RESERVED},
+      {"CAUSE",			CAUSE,			NORID,	RESERVED},
+      {"exit",			EXIT,			NORID,	RESERVED},
+      {"all",			ALL,			NORID,	RESERVED},
+      {"BIN",			BIN,			NORID,	RESERVED},
+      {"dcl",			DCL,			NORID,	RESERVED},
+      {"PACK",			PACK,			NORID,	RESERVED},
+      {"BEGIN",			BEGINTOKEN,		NORID,	RESERVED},
+      {"LARGE",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"ACCESS",			ACCESS,			NORID,	RESERVED},
+      {"this",			THIS,			NORID,	RESERVED},
+      {"with",			WITH,			NORID,	RESERVED},
+      {"END",			END,			NORID,	RESERVED},
+      {"REM",			REM,			NORID,	RESERVED},
+      {"PROCESS",		PROCESS,		NORID,	RESERVED},
       {"CHARS",			CHARS,			NORID,	RESERVED},
-      {"UP",			UP,			NORID,	RESERVED},
-      {"spec",			SPEC,			NORID,	RESERVED},
-      {"SYN",			SYN,			NORID,	RESERVED},
-      {"GRANT",			GRANT,			NORID,	RESERVED},
-      {"MOD",			MOD,			NORID,	RESERVED},
+      {"BOOLS",			BOOLS,			RID_BOOLS,	RESERVED},
+      {"pos",			POS,			NORID,	RESERVED},
+      {"RECURSIVE",		RECURSIVE,		NORID,	RESERVED},
+      {"medium",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"step",			STEP,			NORID,	RESERVED},
+      {"SEND",			SEND,			NORID,	RESERVED},
+      {"CALL",			CALL,			NORID,	RESERVED},
+      {"REF",			REF,			NORID,	RESERVED},
+      {"OF",			OF,			NORID,	RESERVED},
+      {"cycle",			CYCLE,			NORID,	RESERVED},
+      {"array",			ARRAY,			NORID,	RESERVED},
+      {"call",			CALL,			NORID,	RESERVED},
+      {"ELSIF",			ELSIF,			NORID,	RESERVED},
+      {"bit",			BOOLS,			RID_BOOLS,	PREDEF},
+      {"BODY",			BODY,			NORID,	RESERVED},
+      {"recursive",		RECURSIVE,		NORID,	RESERVED},
       {"small",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"DCL",			DCL,			NORID,	RESERVED},
-      {"ever",			EVER,			NORID,	RESERVED},
+      {"delay",			DELAY,			NORID,	RESERVED},
+      {"of",			OF,			NORID,	RESERVED},
+      {"REGION",			REGION,			NORID,	RESERVED},
+      {"prefixed",		PREFIXED,		NORID,	RESERVED},
+      {"READ",			READ,			RID_READ,	RESERVED},
+      {"use_seize_file",		USE_SEIZE_FILE,		NORID,	DIRECTIVE},
+      {"or",			OR,			NORID,	RESERVED},
       {"do",			DO,			NORID,	RESERVED},
       {"od",			OD,			NORID,	RESERVED},
-      {"case",			CASE,			NORID,	RESERVED},
-      {"esac",			ESAC,			NORID,	RESERVED},
-      {"CCITT_OS",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"xor",			XOR,			NORID,	RESERVED},
+      {"row",			ROW,			NORID,	RESERVED},
+      {"DOWN",			DOWN,			NORID,	RESERVED},
+      {"SIMPLE",			SIMPLE,			NORID,	RESERVED},
+      {"BASED",			BASED,			NORID,	RESERVED},
+      {"assert",			ASSERT,			NORID,	RESERVED},
       {"FOR",			FOR,			NORID,	RESERVED},
-      {"ORIF",			ORIF,			NORID,	RESERVED},
-      {"BODY",			BODY,			NORID,	RESERVED},
-      {"INOUT",			PARAMATTR,		RID_INOUT,	RESERVED},
-      {"SIGNAL",			SIGNAL,			NORID,	RESERVED},
-      {"LOC",			LOC,			NORID,	RESERVED},
-      {"NOLIST",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"DELAY",			DELAY,			NORID,	RESERVED},
+      {"ASM",			ASM_KEYWORD,		NORID,	RESERVED},
       {"even",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"in",			IN,			RID_IN,	RESERVED},
-      {"ALL",			ALL,			NORID,	RESERVED},
-      {"NOPACK",			NOPACK,			NORID,	RESERVED},
-      {"call",			CALL,			NORID,	RESERVED},
-      {"pos",			POS,			NORID,	RESERVED},
-      {"end",			END,			NORID,	RESERVED},
-      {"send",			SEND,			NORID,	RESERVED},
-      {"of",			OF,			NORID,	RESERVED},
-      {"PROC",			PROC,			NORID,	RESERVED},
-      {"to",			TO,			NORID,	RESERVED},
-      {"rem",			REM,			NORID,	RESERVED},
-      {"pack",			PACK,			NORID,	RESERVED},
-      {"BOOLS",			BOOLS,			RID_BOOLS,	RESERVED},
+      {"RANGE",			RANGE,			NORID,	RESERVED},
+      {"list",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"ORIF",			ORIF,			NORID,	RESERVED},
+      {"buffer",			BUFFER,			NORID,	RESERVED},
+      {"MOD",			MOD,			NORID,	RESERVED},
+      {"SIGNAL",			SIGNAL,			NORID,	RESERVED},
       {"mod",			MOD,			NORID,	RESERVED},
-      {"ref",			REF,			NORID,	RESERVED},
-      {"use_seize_file",		USE_SEIZE_FILE,		NORID,	DIRECTIVE},
+      {"USE_SEIZE_FILE",		USE_SEIZE_FILE,		NORID,	DIRECTIVE},
+      {"loc",			LOC,			NORID,	RESERVED},
+      {"INLINE",			INLINE,			RID_INLINE,	RESERVED},
+      {"proc",			PROC,			NORID,	RESERVED},
+      {"AND",			AND,			NORID,	RESERVED},
+      {"process",		PROCESS,		NORID,	RESERVED},
+      {"for",			FOR,			NORID,	RESERVED},
       {"bin",			BIN,			NORID,	RESERVED},
-      {"medium",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"GENERAL",		GENERAL,		NORID,	RESERVED},
       {"begin",			BEGINTOKEN,		NORID,	RESERVED},
-      {"FORBID",			FORBID,			NORID,	RESERVED},
+      {"orif",			ORIF,			NORID,	RESERVED},
+      {"after",			AFTER,			NORID,	RESERVED},
+      {"FAR",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"syn",			SYN,			NORID,	RESERVED},
+      {"SMALL",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"end",			END,			NORID,	RESERVED},
+      {"send",			SEND,			NORID,	RESERVED},
+      {"VARYING",		VARYING,		NORID,	RESERVED},
+      {"and",			AND,			NORID,	RESERVED},
+      {"range",			RANGE,			NORID,	RESERVED},
       {"body",			BODY,			NORID,	RESERVED},
+      {"MODULE",			MODULE,			NORID,	RESERVED},
       {"ARRAY",			ARRAY,			NORID,	RESERVED},
-      {"STRUCT",			STRUCT,			NORID,	RESERVED},
-      {"read",			READ,			RID_READ,	RESERVED},
-      {"cycle",			CYCLE,			NORID,	RESERVED},
-      {"large",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"VARYING",		VARYING,		NORID,	RESERVED},
-      {"CALL",			CALL,			NORID,	RESERVED},
-      {"then",			THEN,			NORID,	RESERVED},
-      {"event",			EVENT,			NORID,	RESERVED},
-      {"cause",			CAUSE,			NORID,	RESERVED},
-      {"loc",			LOC,			NORID,	RESERVED},
-      {"access",			ACCESS,			NORID,	RESERVED},
-      {"init",			INIT,			NORID,	RESERVED},
-      {"receive",		RECEIVE,		NORID,	RESERVED},
-      {"TEXT",			TEXT,			NORID,	RESERVED},
-      {"EXIT",			EXIT,			NORID,	RESERVED},
-      {"stop",			STOP,			NORID,	RESERVED},
+      {"DEBUG_LINES",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"to",			TO,			NORID,	RESERVED},
       {"SET",			SET,			NORID,	RESERVED},
-      {"and",			AND,			NORID,	RESERVED},
+      {"text",			TEXT,			NORID,	RESERVED},
+      {"NOPACK",			NOPACK,			NORID,	RESERVED},
+      {"PREFIXED",		PREFIXED,		NORID,	RESERVED},
+      {"WITH",			WITH,			NORID,	RESERVED},
+      {"EXIT",			EXIT,			NORID,	RESERVED},
       {"signal",			SIGNAL,			NORID,	RESERVED},
-      {"far",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"assert",			ASSERT,			NORID,	RESERVED},
+      {"THIS",			THIS,			NORID,	RESERVED},
+      {"stop",			STOP,			NORID,	RESERVED},
+      {"result",			RESULT,			NORID,	RESERVED},
+      {"TO",			TO,			NORID,	RESERVED},
       {"static",			STATIC,			NORID,	RESERVED},
-      {"debug_types",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"prefixed",		PREFIXED,		NORID,	RESERVED},
       {"out",			PARAMATTR,		RID_OUT,	RESERVED},
-      {"THEN",			THEN,			NORID,	RESERVED},
-      {"or",			OR,			NORID,	RESERVED},
-      {"END",			END,			NORID,	RESERVED},
-      {"row",			ROW,			NORID,	RESERVED},
       {"STEP",			STEP,			NORID,	RESERVED},
-      {"xor",			XOR,			NORID,	RESERVED},
-      {"SMALL",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"PRIORITY",		PRIORITY,		NORID,	RESERVED},
-      {"SEND",			SEND,			NORID,	RESERVED},
-      {"BASED",			BASED,			NORID,	RESERVED},
-      {"chars",			CHARS,			NORID,	RESERVED},
-      {"DYNAMIC",		DYNAMIC,		RID_DYNAMIC,	RESERVED},
-      {"CASE",			CASE,			NORID,	RESERVED},
-      {"ESAC",			ESAC,			NORID,	RESERVED},
+      {"NEWMODE",		NEWMODE,		NORID,	RESERVED},
+      {"LIST",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"andif",			ANDIF,			NORID,	RESERVED},
+      {"varying",		VARYING,		NORID,	RESERVED},
+      {"FORBID",			FORBID,			NORID,	RESERVED},
+      {"BIT",			BOOLS,			RID_BOOLS,	PREDEF},
+      {"forbid",			FORBID,			NORID,	RESERVED},
       {"module",			MODULE,			NORID,	RESERVED},
+      {"OUT",			PARAMATTR,		RID_OUT,	RESERVED},
+      {"debug_types",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"MEDIUM",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"start",			START,			NORID,	RESERVED},
+      {"general",		GENERAL,		NORID,	RESERVED},
       {"on",			ON,			NORID,	RESERVED},
-      {"result",			RESULT,			NORID,	RESERVED},
-      {"PAGE",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"andif",			ANDIF,			NORID,	RESERVED},
-      {"READ",			READ,			RID_READ,	RESERVED},
+      {"RANGE_ON",		RANGE_ON,		NORID,	DIRECTIVE},
+      {"event",			EVENT,			NORID,	RESERVED},
+      {"SYNMODE",		SYNMODE,		NORID,	RESERVED},
+      {"GOTO",			GOTO,			NORID,	RESERVED},
+      {"STOP",			STOP,			NORID,	RESERVED},
+      {"AT",			AT,			NORID,	RESERVED},
+      {"init",			INIT,			NORID,	RESERVED},
+      {"optimize",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"then",			THEN,			NORID,	RESERVED},
+      {"SIGNAL_CODE",		SIGNAL_CODE,		NORID,	DIRECTIVE},
+      {"powerset",		POWERSET,		NORID,	RESERVED},
+      {"BUFFER",			BUFFER,			NORID,	RESERVED},
+      {"THEN",			THEN,			NORID,	RESERVED},
+      {"remote",			REMOTE,			NORID,	RESERVED},
+      {"RESULT",			RESULT,			NORID,	RESERVED},
+      {"EVENT",			EVENT,			NORID,	RESERVED},
+      {"dynamic",		DYNAMIC,		RID_DYNAMIC,	RESERVED},
+      {"ANDIF",			ANDIF,			NORID,	RESERVED},
       {"bools",			BOOLS,			RID_BOOLS,	RESERVED},
+      {"NONREF",			NONREF,			NORID,	RESERVED},
+      {"INIT",			INIT,			NORID,	RESERVED},
+      {"nopack",			NOPACK,			NORID,	RESERVED},
+      {"struct",			STRUCT,			NORID,	RESERVED},
+      {"POWERSET",		POWERSET,		NORID,	RESERVED},
+      {"NOT",			NOT,			NORID,	RESERVED},
+      {"down",			DOWN,			NORID,	RESERVED},
+      {"grant",			GRANT,			NORID,	RESERVED},
+      {"region",			REGION,			NORID,	RESERVED},
       {"ASSERT",			ASSERT,			NORID,	RESERVED},
+      {"DEBUG_SYMBOLS",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"debug_lines",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"after",			AFTER,			NORID,	RESERVED},
-      {"ALL_STATIC_ON",		ALL_STATIC_ON,		NORID,	DIRECTIVE},
-      {"down",			DOWN,			NORID,	RESERVED},
-      {"WHILE",			WHILE,			NORID,	RESERVED},
-      {"start",			START,			NORID,	RESERVED},
-      {"optimize",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"goto",			GOTO,			NORID,	RESERVED},
-      {"for",			FOR,			NORID,	RESERVED},
-      {"SPEC",			SPEC,			NORID,	RESERVED},
-      {"orif",			ORIF,			NORID,	RESERVED},
-      {"BEGIN",			BEGINTOKEN,		NORID,	RESERVED},
-      {"REF",			REF,			NORID,	RESERVED},
-      {"OPTIMIZATION_WINDOW",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"ACCESS",			ACCESS,			NORID,	RESERVED},
-      {"AFTER",			AFTER,			NORID,	RESERVED},
-      {"not",			NOT,			NORID,	RESERVED},
-      {"buffer",			BUFFER,			NORID,	RESERVED},
-      {"inline",			INLINE,			RID_INLINE,	RESERVED},
-      {"CONTEXT",		CONTEXT,		NORID,	RESERVED},
-      {"RANGE",			RANGE,			NORID,	RESERVED},
+      {"DYNAMIC",		DYNAMIC,		RID_DYNAMIC,	RESERVED},
+      {"NO_OVERLAP_CHECK",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"newmode",		NEWMODE,		NORID,	RESERVED},
-      {"range",			RANGE,			NORID,	RESERVED},
-      {"forbid",			FORBID,			NORID,	RESERVED},
-      {"nolist",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"CAUSE",			CAUSE,			NORID,	RESERVED},
-      {"ELSIF",			ELSIF,			NORID,	RESERVED},
-      {"remote",			REMOTE,			NORID,	RESERVED},
-      {"timeout",		TIMEOUT,		NORID,	RESERVED},
-      {"powerset",		POWERSET,		NORID,	RESERVED},
+      {"buffer_code",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"INOUT",			PARAMATTR,		RID_INOUT,	RESERVED},
+      {"NOLIST",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"process_type",		PROCESS_TYPE_TOKEN,	NORID,	DIRECTIVE},
       {"debug_symbols",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"general",		GENERAL,		NORID,	RESERVED},
-      {"REGION",			REGION,			NORID,	RESERVED},
-      {"REM",			REM,			NORID,	RESERVED},
-      {"ALL_STATIC_OFF",		ALL_STATIC_OFF,		NORID,  DIRECTIVE},
-      {"INLINE",			INLINE,			RID_INLINE,	RESERVED},
-      {"synmode",		SYNMODE,		NORID,	RESERVED},
-      {"proc",			PROC,			NORID,	RESERVED},
-      {"LARGE",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"DELAY",			DELAY,			NORID,	RESERVED},
-      {"process",		PROCESS,		NORID,	RESERVED},
-      {"OPTIMIZE",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"varying",		VARYING,		NORID,	RESERVED},
-      {"dynamic",		DYNAMIC,		RID_DYNAMIC,	RESERVED},
+      {"RETURN",			RETURN,			NORID,	RESERVED},
+      {"priority",		PRIORITY,		NORID,	RESERVED},
+      {"REMOTE",			REMOTE,			NORID,	RESERVED},
       {"ccitt_os",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"struct",			STRUCT,			NORID,	RESERVED},
-      {"grant",			GRANT,			NORID,	RESERVED},
+      {"RETURNS",		RETURNS,		NORID,	RESERVED},
       {"empty_off",		EMPTY_OFF,		NORID,	DIRECTIVE},
-      {"PROCESS",		PROCESS,		NORID,	RESERVED},
-      {"RANGE_ON",		RANGE_ON,		NORID,	DIRECTIVE},
-      {"inout",			PARAMATTR,		RID_INOUT,	RESERVED},
-      {"array",			ARRAY,			NORID,	RESERVED},
-      {"region",			REGION,			NORID,	RESERVED},
-      {"TIMEOUT",		TIMEOUT,		NORID,	RESERVED},
-      {"recursive",		RECURSIVE,		NORID,	RESERVED},
-      {"event_code",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"NONREF",			NONREF,			NORID,	RESERVED},
-      {"SIMPLE",			SIMPLE,			NORID,	RESERVED},
-      {"SEIZE",			SEIZE,			NORID,	RESERVED},
-      {"RESULT",			RESULT,			NORID,	RESERVED},
-      {"multiple_data_segs",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"PRIORITY",		PRIORITY,		NORID,	RESERVED},
+      {"DEBUG_TYPES",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"synmode",		SYNMODE,		NORID,	RESERVED},
+      {"not",			NOT,			NORID,	RESERVED},
+      {"GRANT",			GRANT,			NORID,	RESERVED},
+      {"EXCEPTIONS",		EXCEPTIONS,		NORID,	RESERVED},
+      {"timeout",		TIMEOUT,		NORID,	RESERVED},
+      {"BUFFER_CODE",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"return",			RETURN,			NORID,	RESERVED},
+      {"inline",			INLINE,			RID_INLINE,	RESERVED},
+      {"returns",		RETURNS,		NORID,	RESERVED},
+      {"PROCESS_TYPE",		PROCESS_TYPE_TOKEN,	NORID,	DIRECTIVE},
+      {"OPTIMIZE",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"range_off",		RANGE_OFF,		NORID,	DIRECTIVE},
+      {"EVENT_CODE",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"RANGE_OFF",		RANGE_OFF,		NORID,	DIRECTIVE},
       {"signal_code",		SIGNAL_CODE,		NORID,	DIRECTIVE},
-      {"RETURN",			RETURN,			NORID,	RESERVED},
+      {"AFTER",			AFTER,			NORID,	RESERVED},
+      {"inout",			PARAMATTR,		RID_INOUT,	RESERVED},
+      {"exceptions",		EXCEPTIONS,		NORID,	RESERVED},
+      {"TEXT",			TEXT,			NORID,	RESERVED},
+      {"grant_file_size",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"CONTINUE",		CONTINUE,		NORID,	RESERVED},
-      {"SIGNAL_CODE",		SIGNAL_CODE,		NORID,	DIRECTIVE},
+      {"nolist",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"short_pred_succ",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"event_code",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"EMPTY_ON",		EMPTY_ON,		NORID,	DIRECTIVE},
       {"empty_on",		EMPTY_ON,		NORID,	DIRECTIVE},
-      {"nopack",			NOPACK,			NORID,	RESERVED},
-      {"RETURNS",		RETURNS,		NORID,	RESERVED},
-      {"CYCLE",			CYCLE,			NORID,	RESERVED},
-      {"SYNMODE",		SYNMODE,		NORID,	RESERVED},
-      {"exceptions",		EXCEPTIONS,		NORID,	RESERVED},
-      {"EVEN",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"SHORT_PRED_SUCC",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"multiple_data_segs",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"range_on",		RANGE_ON,		NORID,	DIRECTIVE},
       {"PRINT_O_CODE",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"EVENT",			EVENT,			NORID,	RESERVED},
+      {"STRUCT",			STRUCT,			NORID,	RESERVED},
       {"context",		CONTEXT,		NORID,	RESERVED},
-      {"RANGE_OFF",		RANGE_OFF,		NORID,	DIRECTIVE},
-      {"EVER",			EVER,			NORID,	RESERVED},
-      {"EMPTY_ON",		EMPTY_ON,		NORID,	DIRECTIVE},
-      {"MEDIUM",			IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"BUFFER",			BUFFER,			NORID,	RESERVED},
-      {"MODULE",			MODULE,			NORID,	RESERVED},
-      {"grant_file_size",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"ELSE",			ELSE,			NORID,	RESERVED},
-      {"process_type",		PROCESS_TYPE_TOKEN,	NORID,	DIRECTIVE},
-      {"priority",		PRIORITY,		NORID,	RESERVED},
-      {"buffer_code",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"return",			RETURN,			NORID,	RESERVED},
-      {"returns",		RETURNS,		NORID,	RESERVED},
+      {"nonref",			NONREF,			NORID,	RESERVED},
+      {"CCITT_OS",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"use_seize_file_restricted",	USE_SEIZE_FILE_RESTRICTED,	NORID,	DIRECTIVE},
+      {"START",			START,			NORID,	RESERVED},
+      {"STATIC",			STATIC,			NORID,	RESERVED},
+      {"GRANT_FILE_SIZE",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"all_static_off",		ALL_STATIC_OFF,		NORID,  DIRECTIVE},
-      {"POWERSET",		POWERSET,		NORID,	RESERVED},
+      {"no_overlap_check",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"CONTEXT",		CONTEXT,		NORID,	RESERVED},
+      {"extra_const_seg",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"TIMEOUT",		TIMEOUT,		NORID,	RESERVED},
       {"EMPTY_OFF",		EMPTY_OFF,		NORID,	DIRECTIVE},
-      {"range_off",		RANGE_OFF,		NORID,	DIRECTIVE},
+      {"continue",		CONTINUE,		NORID,	RESERVED},
       {"signal_max_length",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"PREFIXED",		PREFIXED,		NORID,	RESERVED},
-      {"NEWMODE",		NEWMODE,		NORID,	RESERVED},
-      {"EXCEPTIONS",		EXCEPTIONS,		NORID,	RESERVED},
-      {"REMOTE",			REMOTE,			NORID,	RESERVED},
-      {"SHORT_PRED_SUCC",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"print_o_code",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"generate_set_names",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"all_static_on",		ALL_STATIC_ON,		NORID,	DIRECTIVE},
-      {"nonref",			NONREF,			NORID,	RESERVED},
+      {"reentrant",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"SIGNAL_MAX_LENGTH",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"REENTRANT",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"range_on",		RANGE_ON,		NORID,	DIRECTIVE},
-      {"GENERAL",		GENERAL,		NORID,	RESERVED},
-      {"continue",		CONTINUE,		NORID,	RESERVED},
-      {"STATE_ROUTINE",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"optimize_runtime",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"EXTRA_CONST_SEG",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"use_seize_file_restricted",	USE_SEIZE_FILE_RESTRICTED,	NORID,	DIRECTIVE},
-      {"ONLY_FOR_TARGET",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"extra_const_seg",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"multiple_const_segs",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"RECURSIVE",		RECURSIVE,		NORID,	RESERVED},
-      {"DEBUG_SYMBOLS",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"DEBUG_TYPES",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"GRANT_FILE_SIZE",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"DEBUG_LINES",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"ONLY_FOR_SIMULATION",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"support_causing_address",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"state_routine",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"generate_set_names",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"print_o_code",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"PROCESS_TYPE",		PROCESS_TYPE_TOKEN,	NORID,	DIRECTIVE},
-      {"short_pred_succ",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"reentrant",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"RECEIVE",		RECEIVE,		NORID,	RESERVED},
-      {"EVENT_CODE",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"optimize_runtime",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"REENTRANT",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"multiple_const_segs",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"ALL_STATIC_ON",		ALL_STATIC_ON,		NORID,	DIRECTIVE},
+      {"generate_all_set_names",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"reentrant_all",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"USE_SEIZE_FILE_RESTRICTED",	USE_SEIZE_FILE_RESTRICTED,	NORID,	DIRECTIVE},
+      {"MULTIPLE_CONST_SEGS",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"SUPPORT_CAUSING_ADDRESS",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"print_symbol_table",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"make_publics_for_discrete_syns",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"REENTRANT_ALL",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"PRINT_SYMBOL_TABLE",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"BUFFER_CODE",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"generate_all_set_names",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"NO_OVERLAP_CHECK",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"no_overlap_check",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"reentrant_all",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"MULTIPLE_DATA_SEGS",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"OPTIMIZE_RUNTIME",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"only_for_target",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"MULTIPLE_CONST_SEGS",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"optimization_window",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"support_causing_address",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"USE_SEIZE_FILE",		USE_SEIZE_FILE,		NORID,	DIRECTIVE},
-      {"SEND_SIGNAL_DEFAULT_PRIORITY",	SEND_SIGNAL_DEFAULT_PRIORITY,	NORID,	DIRECTIVE},
-      {"make_publics_for_discrete_syns",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"only_for_simulation",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"send_signal_default_priority",	SEND_SIGNAL_DEFAULT_PRIORITY,	NORID,	DIRECTIVE},
-      {"send_buffer_default_priority",	SEND_BUFFER_DEFAULT_PRIORITY,	NORID,	DIRECTIVE},
+      {"OPTIMIZE_RUNTIME",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"ONLY_FOR_TARGET",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"GENERATE_SET_NAMES",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"ONLY_FOR_SIMULATION",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"ALL_STATIC_OFF",		ALL_STATIC_OFF,		NORID,  DIRECTIVE},
+      {"STATE_ROUTINE",		IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"PRINT_SYMBOL_TABLE",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
       {"MAKE_PUBLICS_FOR_DISCRETE_SYNS",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"SEND_BUFFER_DEFAULT_PRIORITY",	SEND_BUFFER_DEFAULT_PRIORITY,	NORID,	DIRECTIVE},
       {"GENERATE_ALL_SET_NAMES",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
-      {"USE_SEIZE_FILE_RESTRICTED",	USE_SEIZE_FILE_RESTRICTED,	NORID,	DIRECTIVE}
+      {"OPTIMIZATION_WINDOW",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"optimization_window",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"send_buffer_default_priority",	SEND_BUFFER_DEFAULT_PRIORITY,	NORID,	DIRECTIVE},
+      {"only_for_simulation",	IGNORED_DIRECTIVE,	NORID,	DIRECTIVE},
+      {"send_signal_default_priority",	SEND_SIGNAL_DEFAULT_PRIORITY,	NORID,	DIRECTIVE},
+      {"SEND_SIGNAL_DEFAULT_PRIORITY",	SEND_SIGNAL_DEFAULT_PRIORITY,	NORID,	DIRECTIVE},
+      {"SEND_BUFFER_DEFAULT_PRIORITY",	SEND_BUFFER_DEFAULT_PRIORITY,	NORID,	DIRECTIVE}
     };
 
   if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
@@ -451,7 +451,7 @@ in_word_set (str, len)
           register struct resword *wordendptr;
           register struct resword *resword;
 
-          switch (key - 7)
+          switch (key - 40)
             {
               case 0:
                 resword = &wordlist[0];
@@ -459,448 +459,448 @@ in_word_set (str, len)
               case 5:
                 resword = &wordlist[1];
                 goto compare;
-              case 16:
+              case 8:
                 resword = &wordlist[2];
                 goto compare;
-              case 23:
-                resword = &wordlist[3];
-                goto compare;
-              case 36:
-                resword = &wordlist[4];
-                goto compare;
-              case 42:
+              case 9:
+                wordptr = &wordlist[3];
+                wordendptr = wordptr + 2;
+                goto multicompare;
+              case 20:
                 resword = &wordlist[5];
                 goto compare;
-              case 48:
+              case 22:
                 resword = &wordlist[6];
                 goto compare;
-              case 53:
-                wordptr = &wordlist[7];
-                wordendptr = wordptr + 2;
-                goto multicompare;
-              case 60:
-                resword = &wordlist[9];
+              case 34:
+                resword = &wordlist[7];
                 goto compare;
-              case 61:
-                resword = &wordlist[10];
+              case 36:
+                resword = &wordlist[8];
                 goto compare;
-              case 66:
-                resword = &wordlist[11];
+              case 41:
+                resword = &wordlist[9];
                 goto compare;
-              case 76:
-                resword = &wordlist[12];
+              case 42:
+                resword = &wordlist[10];
                 goto compare;
-              case 83:
-                wordptr = &wordlist[13];
+              case 47:
+                wordptr = &wordlist[11];
                 wordendptr = wordptr + 2;
                 goto multicompare;
-              case 86:
+              case 49:
+                resword = &wordlist[13];
+                goto compare;
+              case 55:
+                resword = &wordlist[14];
+                goto compare;
+              case 59:
                 resword = &wordlist[15];
                 goto compare;
-              case 88:
-                wordptr = &wordlist[16];
-                wordendptr = wordptr + 2;
-                goto multicompare;
-              case 91:
+              case 64:
+                resword = &wordlist[16];
+                goto compare;
+              case 70:
+                resword = &wordlist[17];
+                goto compare;
+              case 80:
                 resword = &wordlist[18];
                 goto compare;
-              case 94:
+              case 84:
                 resword = &wordlist[19];
                 goto compare;
-              case 99:
+              case 86:
                 resword = &wordlist[20];
                 goto compare;
-              case 100:
+              case 93:
                 resword = &wordlist[21];
                 goto compare;
-              case 103:
+              case 94:
                 resword = &wordlist[22];
                 goto compare;
-              case 105:
+              case 96:
                 resword = &wordlist[23];
                 goto compare;
-              case 107:
+              case 97:
                 resword = &wordlist[24];
                 goto compare;
-              case 111:
+              case 101:
                 resword = &wordlist[25];
                 goto compare;
-              case 113:
+              case 107:
                 resword = &wordlist[26];
                 goto compare;
-              case 116:
+              case 108:
                 resword = &wordlist[27];
                 goto compare;
-              case 120:
+              case 109:
                 resword = &wordlist[28];
                 goto compare;
-              case 121:
+              case 111:
                 resword = &wordlist[29];
                 goto compare;
-              case 122:
+              case 116:
                 resword = &wordlist[30];
                 goto compare;
-              case 123:
+              case 117:
                 resword = &wordlist[31];
                 goto compare;
-              case 129:
+              case 118:
                 resword = &wordlist[32];
                 goto compare;
-              case 131:
+              case 128:
                 resword = &wordlist[33];
                 goto compare;
-              case 132:
+              case 134:
                 resword = &wordlist[34];
                 goto compare;
-              case 136:
+              case 135:
                 resword = &wordlist[35];
                 goto compare;
-              case 137:
-                resword = &wordlist[36];
-                goto compare;
-              case 140:
-                resword = &wordlist[37];
-                goto compare;
-              case 142:
+              case 136:
+                wordptr = &wordlist[36];
+                wordendptr = wordptr + 2;
+                goto multicompare;
+              case 139:
                 resword = &wordlist[38];
                 goto compare;
-              case 146:
+              case 145:
                 resword = &wordlist[39];
                 goto compare;
-              case 150:
+              case 156:
                 resword = &wordlist[40];
                 goto compare;
-              case 155:
-                resword = &wordlist[41];
-                goto compare;
               case 157:
-                resword = &wordlist[42];
-                goto compare;
-              case 163:
-                resword = &wordlist[43];
+                resword = &wordlist[41];
                 goto compare;
-              case 165:
+              case 161:
+                wordptr = &wordlist[42];
+                wordendptr = wordptr + 2;
+                goto multicompare;
+              case 167:
                 resword = &wordlist[44];
                 goto compare;
-              case 167:
+              case 171:
                 resword = &wordlist[45];
                 goto compare;
-              case 168:
+              case 173:
                 resword = &wordlist[46];
                 goto compare;
-              case 171:
+              case 179:
                 resword = &wordlist[47];
                 goto compare;
-              case 175:
+              case 180:
                 resword = &wordlist[48];
                 goto compare;
-              case 177:
+              case 184:
                 resword = &wordlist[49];
                 goto compare;
-              case 178:
+              case 190:
                 resword = &wordlist[50];
                 goto compare;
-              case 180:
-                resword = &wordlist[51];
-                goto compare;
-              case 184:
-                resword = &wordlist[52];
-                goto compare;
-              case 187:
+              case 192:
+                wordptr = &wordlist[51];
+                wordendptr = wordptr + 2;
+                goto multicompare;
+              case 198:
                 resword = &wordlist[53];
                 goto compare;
-              case 189:
+              case 199:
                 resword = &wordlist[54];
                 goto compare;
-              case 193:
+              case 201:
                 resword = &wordlist[55];
                 goto compare;
-              case 194:
+              case 204:
                 resword = &wordlist[56];
                 goto compare;
-              case 195:
+              case 206:
                 resword = &wordlist[57];
                 goto compare;
-              case 196:
+              case 207:
                 resword = &wordlist[58];
                 goto compare;
-              case 197:
+              case 210:
                 resword = &wordlist[59];
                 goto compare;
-              case 202:
+              case 212:
                 resword = &wordlist[60];
                 goto compare;
-              case 209:
+              case 213:
                 resword = &wordlist[61];
                 goto compare;
-              case 213:
+              case 214:
                 resword = &wordlist[62];
                 goto compare;
-              case 217:
+              case 215:
                 resword = &wordlist[63];
                 goto compare;
               case 218:
                 resword = &wordlist[64];
                 goto compare;
-              case 219:
-                wordptr = &wordlist[65];
-                wordendptr = wordptr + 2;
-                goto multicompare;
               case 220:
-                wordptr = &wordlist[67];
-                wordendptr = wordptr + 2;
-                goto multicompare;
+                resword = &wordlist[65];
+                goto compare;
+              case 221:
+                resword = &wordlist[66];
+                goto compare;
+              case 222:
+                resword = &wordlist[67];
+                goto compare;
+              case 223:
+                resword = &wordlist[68];
+                goto compare;
               case 225:
                 resword = &wordlist[69];
                 goto compare;
-              case 229:
+              case 226:
                 resword = &wordlist[70];
                 goto compare;
-              case 232:
+              case 227:
                 resword = &wordlist[71];
                 goto compare;
-              case 240:
+              case 228:
                 resword = &wordlist[72];
                 goto compare;
-              case 246:
+              case 229:
                 resword = &wordlist[73];
                 goto compare;
-              case 250:
+              case 231:
                 resword = &wordlist[74];
                 goto compare;
-              case 251:
+              case 232:
                 resword = &wordlist[75];
                 goto compare;
-              case 254:
+              case 234:
                 resword = &wordlist[76];
                 goto compare;
-              case 255:
+              case 235:
                 resword = &wordlist[77];
                 goto compare;
-              case 257:
+              case 236:
                 resword = &wordlist[78];
                 goto compare;
-              case 258:
+              case 237:
                 resword = &wordlist[79];
                 goto compare;
-              case 262:
+              case 239:
                 resword = &wordlist[80];
                 goto compare;
-              case 264:
+              case 241:
                 resword = &wordlist[81];
                 goto compare;
-              case 270:
+              case 245:
                 resword = &wordlist[82];
                 goto compare;
-              case 273:
+              case 250:
                 resword = &wordlist[83];
                 goto compare;
-              case 275:
+              case 255:
                 resword = &wordlist[84];
                 goto compare;
-              case 279:
+              case 260:
                 resword = &wordlist[85];
                 goto compare;
-              case 284:
+              case 261:
                 resword = &wordlist[86];
                 goto compare;
-              case 286:
+              case 262:
                 resword = &wordlist[87];
                 goto compare;
-              case 289:
+              case 264:
                 resword = &wordlist[88];
                 goto compare;
-              case 291:
+              case 271:
                 resword = &wordlist[89];
                 goto compare;
-              case 293:
+              case 272:
                 resword = &wordlist[90];
                 goto compare;
-              case 294:
+              case 274:
                 resword = &wordlist[91];
                 goto compare;
-              case 296:
+              case 277:
                 resword = &wordlist[92];
                 goto compare;
-              case 297:
+              case 278:
                 resword = &wordlist[93];
                 goto compare;
-              case 298:
+              case 285:
                 resword = &wordlist[94];
                 goto compare;
-              case 300:
-                resword = &wordlist[95];
-                goto compare;
-              case 302:
-                resword = &wordlist[96];
-                goto compare;
-              case 307:
+              case 286:
+                wordptr = &wordlist[95];
+                wordendptr = wordptr + 2;
+                goto multicompare;
+              case 287:
                 resword = &wordlist[97];
                 goto compare;
-              case 308:
+              case 288:
                 resword = &wordlist[98];
                 goto compare;
-              case 317:
+              case 291:
                 resword = &wordlist[99];
                 goto compare;
-              case 322:
+              case 298:
                 resword = &wordlist[100];
                 goto compare;
-              case 325:
+              case 299:
                 resword = &wordlist[101];
                 goto compare;
-              case 331:
+              case 300:
                 resword = &wordlist[102];
                 goto compare;
-              case 332:
+              case 302:
                 resword = &wordlist[103];
                 goto compare;
-              case 335:
+              case 305:
                 resword = &wordlist[104];
                 goto compare;
-              case 336:
+              case 310:
                 resword = &wordlist[105];
                 goto compare;
-              case 339:
+              case 312:
                 resword = &wordlist[106];
                 goto compare;
-              case 342:
+              case 314:
                 resword = &wordlist[107];
                 goto compare;
-              case 344:
+              case 323:
                 resword = &wordlist[108];
                 goto compare;
-              case 345:
+              case 324:
                 resword = &wordlist[109];
                 goto compare;
-              case 349:
+              case 325:
                 resword = &wordlist[110];
                 goto compare;
-              case 350:
+              case 327:
                 resword = &wordlist[111];
                 goto compare;
-              case 354:
+              case 332:
                 resword = &wordlist[112];
                 goto compare;
-              case 356:
+              case 335:
                 resword = &wordlist[113];
                 goto compare;
-              case 357:
+              case 339:
                 resword = &wordlist[114];
                 goto compare;
-              case 358:
+              case 347:
                 resword = &wordlist[115];
                 goto compare;
-              case 359:
+              case 350:
                 resword = &wordlist[116];
                 goto compare;
-              case 360:
+              case 356:
                 resword = &wordlist[117];
                 goto compare;
-              case 366:
+              case 357:
                 resword = &wordlist[118];
                 goto compare;
-              case 380:
+              case 362:
                 resword = &wordlist[119];
                 goto compare;
-              case 389:
+              case 363:
                 resword = &wordlist[120];
                 goto compare;
-              case 402:
+              case 364:
                 resword = &wordlist[121];
                 goto compare;
-              case 404:
+              case 367:
                 resword = &wordlist[122];
                 goto compare;
-              case 408:
+              case 369:
                 resword = &wordlist[123];
                 goto compare;
-              case 410:
+              case 371:
                 resword = &wordlist[124];
                 goto compare;
-              case 411:
+              case 372:
                 resword = &wordlist[125];
                 goto compare;
-              case 415:
+              case 375:
                 resword = &wordlist[126];
                 goto compare;
-              case 416:
+              case 376:
                 resword = &wordlist[127];
                 goto compare;
-              case 422:
+              case 389:
                 resword = &wordlist[128];
                 goto compare;
-              case 423:
+              case 398:
                 resword = &wordlist[129];
                 goto compare;
-              case 426:
+              case 402:
                 resword = &wordlist[130];
                 goto compare;
-              case 427:
+              case 404:
                 resword = &wordlist[131];
                 goto compare;
-              case 428:
+              case 405:
                 resword = &wordlist[132];
                 goto compare;
-              case 433:
+              case 407:
                 resword = &wordlist[133];
                 goto compare;
-              case 436:
+              case 410:
                 resword = &wordlist[134];
                 goto compare;
-              case 438:
+              case 420:
                 resword = &wordlist[135];
                 goto compare;
-              case 439:
+              case 421:
                 resword = &wordlist[136];
                 goto compare;
-              case 441:
+              case 423:
                 resword = &wordlist[137];
                 goto compare;
-              case 444:
-                wordptr = &wordlist[138];
-                wordendptr = wordptr + 2;
-                goto multicompare;
-              case 445:
+              case 425:
+                resword = &wordlist[138];
+                goto compare;
+              case 426:
+                resword = &wordlist[139];
+                goto compare;
+              case 427:
                 resword = &wordlist[140];
                 goto compare;
-              case 453:
+              case 432:
                 resword = &wordlist[141];
                 goto compare;
-              case 454:
+              case 433:
                 resword = &wordlist[142];
                 goto compare;
-              case 455:
+              case 434:
                 resword = &wordlist[143];
                 goto compare;
-              case 456:
+              case 441:
                 resword = &wordlist[144];
                 goto compare;
-              case 459:
+              case 442:
                 resword = &wordlist[145];
                 goto compare;
-              case 468:
+              case 445:
                 resword = &wordlist[146];
                 goto compare;
-              case 476:
+              case 450:
                 resword = &wordlist[147];
                 goto compare;
-              case 479:
+              case 462:
                 resword = &wordlist[148];
                 goto compare;
-              case 480:
+              case 472:
                 resword = &wordlist[149];
                 goto compare;
               case 481:
                 resword = &wordlist[150];
                 goto compare;
-              case 482:
+              case 483:
                 resword = &wordlist[151];
                 goto compare;
-              case 484:
+              case 487:
                 resword = &wordlist[152];
                 goto compare;
-              case 487:
+              case 488:
                 resword = &wordlist[153];
                 goto compare;
               case 491:
@@ -909,436 +909,436 @@ in_word_set (str, len)
               case 492:
                 resword = &wordlist[155];
                 goto compare;
-              case 498:
+              case 494:
                 resword = &wordlist[156];
                 goto compare;
-              case 505:
+              case 499:
                 resword = &wordlist[157];
                 goto compare;
-              case 506:
+              case 508:
                 resword = &wordlist[158];
                 goto compare;
-              case 514:
+              case 511:
                 resword = &wordlist[159];
                 goto compare;
-              case 533:
+              case 519:
                 resword = &wordlist[160];
                 goto compare;
-              case 536:
+              case 522:
                 resword = &wordlist[161];
                 goto compare;
-              case 539:
+              case 524:
                 resword = &wordlist[162];
                 goto compare;
-              case 540:
+              case 527:
                 resword = &wordlist[163];
                 goto compare;
-              case 542:
+              case 528:
                 resword = &wordlist[164];
                 goto compare;
-              case 544:
+              case 530:
                 resword = &wordlist[165];
                 goto compare;
-              case 547:
+              case 532:
                 resword = &wordlist[166];
                 goto compare;
-              case 550:
+              case 538:
                 resword = &wordlist[167];
                 goto compare;
-              case 551:
+              case 545:
                 resword = &wordlist[168];
                 goto compare;
-              case 561:
+              case 546:
                 resword = &wordlist[169];
                 goto compare;
-              case 567:
+              case 547:
                 resword = &wordlist[170];
                 goto compare;
-              case 569:
+              case 551:
                 resword = &wordlist[171];
                 goto compare;
-              case 576:
+              case 554:
                 resword = &wordlist[172];
                 goto compare;
-              case 580:
+              case 555:
                 resword = &wordlist[173];
                 goto compare;
-              case 583:
+              case 556:
                 resword = &wordlist[174];
                 goto compare;
-              case 584:
+              case 557:
                 resword = &wordlist[175];
                 goto compare;
-              case 585:
+              case 558:
                 resword = &wordlist[176];
                 goto compare;
-              case 589:
+              case 560:
                 resword = &wordlist[177];
                 goto compare;
-              case 592:
+              case 562:
                 resword = &wordlist[178];
                 goto compare;
-              case 593:
+              case 563:
                 resword = &wordlist[179];
                 goto compare;
-              case 596:
+              case 569:
                 resword = &wordlist[180];
                 goto compare;
-              case 597:
+              case 576:
                 resword = &wordlist[181];
                 goto compare;
-              case 600:
+              case 579:
                 resword = &wordlist[182];
                 goto compare;
-              case 610:
+              case 581:
                 resword = &wordlist[183];
                 goto compare;
-              case 611:
+              case 587:
                 resword = &wordlist[184];
                 goto compare;
-              case 615:
+              case 594:
                 resword = &wordlist[185];
                 goto compare;
-              case 616:
+              case 599:
                 resword = &wordlist[186];
                 goto compare;
-              case 617:
+              case 608:
                 resword = &wordlist[187];
                 goto compare;
-              case 621:
+              case 611:
                 resword = &wordlist[188];
                 goto compare;
-              case 629:
+              case 620:
                 resword = &wordlist[189];
                 goto compare;
-              case 632:
+              case 622:
                 resword = &wordlist[190];
                 goto compare;
-              case 634:
+              case 626:
                 resword = &wordlist[191];
                 goto compare;
-              case 643:
+              case 633:
                 resword = &wordlist[192];
                 goto compare;
-              case 645:
+              case 635:
                 resword = &wordlist[193];
                 goto compare;
-              case 654:
+              case 642:
                 resword = &wordlist[194];
                 goto compare;
-              case 657:
+              case 643:
                 resword = &wordlist[195];
                 goto compare;
-              case 663:
+              case 646:
                 resword = &wordlist[196];
                 goto compare;
-              case 665:
+              case 648:
                 resword = &wordlist[197];
                 goto compare;
-              case 675:
+              case 652:
                 resword = &wordlist[198];
                 goto compare;
-              case 678:
+              case 660:
                 resword = &wordlist[199];
                 goto compare;
-              case 684:
+              case 675:
                 resword = &wordlist[200];
                 goto compare;
-              case 690:
+              case 677:
                 resword = &wordlist[201];
                 goto compare;
-              case 700:
+              case 692:
                 resword = &wordlist[202];
                 goto compare;
-              case 702:
+              case 695:
                 resword = &wordlist[203];
                 goto compare;
-              case 710:
+              case 699:
                 resword = &wordlist[204];
                 goto compare;
-              case 713:
+              case 712:
                 resword = &wordlist[205];
                 goto compare;
-              case 720:
+              case 716:
                 resword = &wordlist[206];
                 goto compare;
-              case 723:
+              case 717:
                 resword = &wordlist[207];
                 goto compare;
-              case 724:
+              case 740:
                 resword = &wordlist[208];
                 goto compare;
-              case 738:
+              case 743:
                 resword = &wordlist[209];
                 goto compare;
-              case 741:
+              case 746:
                 resword = &wordlist[210];
                 goto compare;
-              case 743:
+              case 748:
                 resword = &wordlist[211];
                 goto compare;
-              case 744:
+              case 752:
                 resword = &wordlist[212];
                 goto compare;
-              case 749:
+              case 756:
                 resword = &wordlist[213];
                 goto compare;
-              case 751:
+              case 767:
                 resword = &wordlist[214];
                 goto compare;
-              case 755:
+              case 769:
                 resword = &wordlist[215];
                 goto compare;
-              case 761:
+              case 770:
                 resword = &wordlist[216];
                 goto compare;
-              case 764:
+              case 772:
                 resword = &wordlist[217];
                 goto compare;
-              case 766:
+              case 774:
                 resword = &wordlist[218];
                 goto compare;
-              case 768:
+              case 782:
                 resword = &wordlist[219];
                 goto compare;
-              case 769:
+              case 784:
                 resword = &wordlist[220];
                 goto compare;
-              case 770:
+              case 788:
                 resword = &wordlist[221];
                 goto compare;
-              case 772:
+              case 789:
                 resword = &wordlist[222];
                 goto compare;
-              case 784:
+              case 790:
                 resword = &wordlist[223];
                 goto compare;
-              case 800:
+              case 791:
                 resword = &wordlist[224];
                 goto compare;
-              case 807:
+              case 792:
                 resword = &wordlist[225];
                 goto compare;
-              case 808:
+              case 795:
                 resword = &wordlist[226];
                 goto compare;
-              case 823:
+              case 802:
                 resword = &wordlist[227];
                 goto compare;
-              case 826:
+              case 806:
                 resword = &wordlist[228];
                 goto compare;
-              case 827:
+              case 811:
                 resword = &wordlist[229];
                 goto compare;
-              case 839:
+              case 813:
                 resword = &wordlist[230];
                 goto compare;
-              case 842:
+              case 831:
                 resword = &wordlist[231];
                 goto compare;
-              case 868:
+              case 841:
                 resword = &wordlist[232];
                 goto compare;
-              case 902:
+              case 860:
                 resword = &wordlist[233];
                 goto compare;
-              case 903:
+              case 872:
                 resword = &wordlist[234];
                 goto compare;
-              case 905:
+              case 893:
                 resword = &wordlist[235];
                 goto compare;
-              case 919:
+              case 898:
                 resword = &wordlist[236];
                 goto compare;
-              case 924:
+              case 902:
                 resword = &wordlist[237];
                 goto compare;
-              case 926:
+              case 903:
                 resword = &wordlist[238];
                 goto compare;
-              case 937:
+              case 914:
                 resword = &wordlist[239];
                 goto compare;
-              case 940:
+              case 943:
                 resword = &wordlist[240];
                 goto compare;
-              case 975:
+              case 944:
                 resword = &wordlist[241];
                 goto compare;
-              case 979:
+              case 945:
                 resword = &wordlist[242];
                 goto compare;
-              case 982:
+              case 946:
                 resword = &wordlist[243];
                 goto compare;
-              case 997:
+              case 990:
                 resword = &wordlist[244];
                 goto compare;
-              case 1000:
+              case 1009:
                 resword = &wordlist[245];
                 goto compare;
-              case 1011:
+              case 1031:
                 resword = &wordlist[246];
                 goto compare;
-              case 1012:
+              case 1048:
                 resword = &wordlist[247];
                 goto compare;
-              case 1016:
+              case 1058:
                 resword = &wordlist[248];
                 goto compare;
-              case 1028:
+              case 1061:
                 resword = &wordlist[249];
                 goto compare;
-              case 1029:
+              case 1080:
                 resword = &wordlist[250];
                 goto compare;
-              case 1032:
+              case 1085:
                 resword = &wordlist[251];
                 goto compare;
-              case 1061:
+              case 1088:
                 resword = &wordlist[252];
                 goto compare;
-              case 1070:
+              case 1102:
                 resword = &wordlist[253];
                 goto compare;
-              case 1075:
+              case 1124:
                 resword = &wordlist[254];
                 goto compare;
-              case 1079:
+              case 1129:
                 resword = &wordlist[255];
                 goto compare;
-              case 1097:
+              case 1137:
                 resword = &wordlist[256];
                 goto compare;
-              case 1098:
+              case 1160:
                 resword = &wordlist[257];
                 goto compare;
-              case 1102:
+              case 1198:
                 resword = &wordlist[258];
                 goto compare;
-              case 1131:
+              case 1209:
                 resword = &wordlist[259];
                 goto compare;
-              case 1145:
+              case 1227:
                 resword = &wordlist[260];
                 goto compare;
-              case 1155:
+              case 1231:
                 resword = &wordlist[261];
                 goto compare;
-              case 1158:
+              case 1277:
                 resword = &wordlist[262];
                 goto compare;
-              case 1160:
+              case 1300:
                 resword = &wordlist[263];
                 goto compare;
-              case 1161:
+              case 1312:
                 resword = &wordlist[264];
                 goto compare;
-              case 1175:
+              case 1317:
                 resword = &wordlist[265];
                 goto compare;
-              case 1187:
+              case 1336:
                 resword = &wordlist[266];
                 goto compare;
-              case 1200:
+              case 1356:
                 resword = &wordlist[267];
                 goto compare;
-              case 1209:
+              case 1376:
                 resword = &wordlist[268];
                 goto compare;
-              case 1210:
+              case 1412:
                 resword = &wordlist[269];
                 goto compare;
-              case 1220:
+              case 1417:
                 resword = &wordlist[270];
                 goto compare;
-              case 1235:
+              case 1446:
                 resword = &wordlist[271];
                 goto compare;
-              case 1264:
+              case 1456:
                 resword = &wordlist[272];
                 goto compare;
-              case 1267:
+              case 1542:
                 resword = &wordlist[273];
                 goto compare;
-              case 1276:
+              case 1549:
                 resword = &wordlist[274];
                 goto compare;
-              case 1294:
+              case 1566:
                 resword = &wordlist[275];
                 goto compare;
-              case 1295:
+              case 1577:
                 resword = &wordlist[276];
                 goto compare;
-              case 1314:
+              case 1588:
                 resword = &wordlist[277];
                 goto compare;
-              case 1317:
+              case 1595:
                 resword = &wordlist[278];
                 goto compare;
-              case 1332:
+              case 1636:
                 resword = &wordlist[279];
                 goto compare;
-              case 1335:
+              case 1657:
                 resword = &wordlist[280];
                 goto compare;
-              case 1338:
+              case 1678:
                 resword = &wordlist[281];
                 goto compare;
-              case 1365:
+              case 1703:
                 resword = &wordlist[282];
                 goto compare;
-              case 1415:
+              case 1719:
                 resword = &wordlist[283];
                 goto compare;
-              case 1441:
+              case 1731:
                 resword = &wordlist[284];
                 goto compare;
-              case 1539:
+              case 1736:
                 resword = &wordlist[285];
                 goto compare;
-              case 1599:
+              case 1755:
                 resword = &wordlist[286];
                 goto compare;
-              case 1647:
+              case 1775:
                 resword = &wordlist[287];
                 goto compare;
-              case 1758:
+              case 1808:
                 resword = &wordlist[288];
                 goto compare;
-              case 1801:
+              case 1830:
                 resword = &wordlist[289];
                 goto compare;
-              case 1868:
+              case 1878:
                 resword = &wordlist[290];
                 goto compare;
-              case 1870:
+              case 1893:
                 resword = &wordlist[291];
                 goto compare;
-              case 1929:
+              case 1987:
                 resword = &wordlist[292];
                 goto compare;
-              case 1982:
+              case 1990:
                 resword = &wordlist[293];
                 goto compare;
-              case 2146:
+              case 2070:
                 resword = &wordlist[294];
                 goto compare;
-              case 2217:
+              case 2157:
                 resword = &wordlist[295];
                 goto compare;
-              case 2376:
+              case 2218:
                 resword = &wordlist[296];
                 goto compare;
-              case 2441:
+              case 2275:
                 resword = &wordlist[297];
                 goto compare;
-              case 2484:
+              case 2423:
                 resword = &wordlist[298];
                 goto compare;
-              case 2814:
+              case 2651:
                 resword = &wordlist[299];
                 goto compare;
             }